blob_id stringlengths 40 40 | directory_id stringlengths 40 40 | path stringlengths 3 264 | content_id stringlengths 40 40 | detected_licenses listlengths 0 85 | license_type stringclasses 2 values | repo_name stringlengths 5 140 | snapshot_id stringlengths 40 40 | revision_id stringlengths 40 40 | branch_name stringclasses 986 values | visit_date timestamp[us] | revision_date timestamp[us] | committer_date timestamp[us] | github_id int64 3.89k 681M ⌀ | star_events_count int64 0 209k | fork_events_count int64 0 110k | gha_license_id stringclasses 23 values | gha_event_created_at timestamp[us] | gha_created_at timestamp[us] | gha_language stringclasses 145 values | src_encoding stringclasses 34 values | language stringclasses 1 value | is_vendor bool 1 class | is_generated bool 2 classes | length_bytes int64 3 10.4M | extension stringclasses 122 values | content stringlengths 3 10.4M | authors listlengths 1 1 | author_id stringlengths 0 158 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
b455f642cb357c8c6012de2286e48eb7dea93094 | b0dd7779c225971e71ae12c1093dc75ed9889921 | /libs/pool/test/test_valgrind_fail_1.cpp | 28c9027321d2f8e88919b7fcbce8d328f506a923 | [
"LicenseRef-scancode-warranty-disclaimer",
"BSL-1.0"
] | permissive | blackberry/Boost | 6e653cd91a7806855a162347a5aeebd2a8c055a2 | fc90c3fde129c62565c023f091eddc4a7ed9902b | refs/heads/1_48_0-gnu | 2021-01-15T14:31:33.706351 | 2013-06-25T16:02:41 | 2013-06-25T16:02:41 | 2,599,411 | 244 | 154 | BSL-1.0 | 2018-10-13T18:35:09 | 2011-10-18T14:25:18 | C++ | UTF-8 | C++ | false | false | 591 | cpp | /* Copyright (C) 2011 John Maddock
*
* Use, modification and distribution is subject to the
* Boost Software License, Version 1.0. (See accompanying
* file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
*/
// Test of bug #2656 (https://svn.boost.org/trac/boost/ticket/2656)
#include <boost/pool/pool.hpp>
#include <iostream>
#include <iomanip>
static const int magic_value = 0x12345678;
int main()
{
boost::pool<> p(sizeof(int));
int* ptr = static_cast<int*>((p.malloc)());
std::cout << *ptr << std::endl; // uninitialized read
return 0;
}
| [
"tvaneerd@rim.com"
] | tvaneerd@rim.com |
f5786b25f0e74bdb4fe057b7189bd5ce448c9b9e | 5960671ed913fa06d9640f741289c6670f200a81 | /kmeans.cpp | ac78b9b911f6570f28c1fe57a2d850e697bb051a | [] | no_license | netbeen/UncleZhow_Utils | 39b412c659fcb89d6a1dce1c4b3d122a522a8db6 | f93fb90ee55cddd1f7af883a7815cb7f7ac19153 | refs/heads/master | 2021-01-10T07:00:59.982807 | 2015-12-02T14:31:44 | 2015-12-02T14:31:44 | 47,763,075 | 3 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,713 | cpp | #include "kmeans.h"
#include <fstream>
KMeans::KMeans()
{
}
void KMeans::main(){
cv::Mat rawImage = cv::imread("/home/netbeen/桌面/周叔项目/stone.png");
cv::Mat mat_sample(rawImage.rows*rawImage.cols, 3, CV_32F);
for(int y_offset = 0; y_offset < rawImage.rows; y_offset++){
for(int x_offset = 0; x_offset < rawImage.cols; x_offset++){
mat_sample.at<float>(y_offset*rawImage.cols+x_offset,0) = (float)rawImage.at<cv::Vec3b>(y_offset,x_offset)[0];
mat_sample.at<float>(y_offset*rawImage.cols+x_offset,1) = (float)rawImage.at<cv::Vec3b>(y_offset,x_offset)[1];
mat_sample.at<float>(y_offset*rawImage.cols+x_offset,2) = (float)rawImage.at<cv::Vec3b>(y_offset,x_offset)[2];
}
}
std::cout << "mat_sample done" << std::endl;
const int kMeansItCount = 10;
const int kMeansType = cv::KMEANS_PP_CENTERS;
cv::Mat label;
cv::kmeans( mat_sample, 32, label,cv::TermCriteria( CV_TERMCRIT_ITER, kMeansItCount, 0.0), 0, kMeansType );
std::ofstream output1("32output.label");
output1 << label;
output1.close();
cv::kmeans( mat_sample, 64, label,cv::TermCriteria( CV_TERMCRIT_ITER, kMeansItCount, 0.0), 0, kMeansType );
std::ofstream output2("64output.label");
output2 << label;
output2.close();
cv::kmeans( mat_sample, 128, label,cv::TermCriteria( CV_TERMCRIT_ITER, kMeansItCount, 0.0), 0, kMeansType );
std::ofstream output3("128output.label");
output3 << label;
output3.close();
cv::kmeans( mat_sample, 256, label,cv::TermCriteria( CV_TERMCRIT_ITER, kMeansItCount, 0.0), 0, kMeansType );
std::ofstream output4("256output.label");
output4 << label;
output4.close();
}
| [
"netbeen.cn@gmail.com"
] | netbeen.cn@gmail.com |
81ac3aec118dc4ca648283b56d0d2cfc512775e5 | 7f7ebd4118d60a08e4988f95a846d6f1c5fd8eda | /wxWidgets-2.9.1/src/osx/carbon/renderer.cpp | d99ff9003159e5183cd22d915c1c0f830fac49c7 | [] | no_license | esrrhs/fuck-music-player | 58656fc49d5d3ea6c34459630c42072bceac9570 | 97f5c541a8295644837ad864f4f47419fce91e5d | refs/heads/master | 2021-05-16T02:34:59.827709 | 2021-05-10T09:48:22 | 2021-05-10T09:48:22 | 39,882,495 | 2 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 30,851 | cpp | ///////////////////////////////////////////////////////////////////////////////
// Name: src/osx/carbon/renderer.cpp
// Purpose: implementation of wxRendererNative for Mac
// Author: Vadim Zeitlin
// Modified by:
// Created: 20.07.2003
// RCS-ID: $Id$
// Copyright: (c) 2003 Vadim Zeitlin <vadim@wxwindows.org>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
// for compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"
#if wxOSX_USE_COCOA_OR_CARBON
#ifdef __BORLANDC__
#pragma hdrstop
#endif
#ifndef WX_PRECOMP
#include "wx/string.h"
#include "wx/dc.h"
#include "wx/bitmap.h"
#include "wx/settings.h"
#include "wx/dcclient.h"
#include "wx/toplevel.h"
#endif
#include "wx/renderer.h"
#include "wx/graphics.h"
#include "wx/dcgraph.h"
#include "wx/osx/private.h"
#ifdef wxHAS_DRAW_TITLE_BAR_BITMAP
#include "wx/image.h"
#include "wx/mstream.h"
#endif // wxHAS_DRAW_TITLE_BAR_BITMAP
// check if we're currently in a paint event
inline bool wxInPaintEvent(wxWindow* win, wxDC& dc)
{
wxUnusedVar(dc);
return ( win->MacGetCGContextRef() != NULL );
}
class WXDLLEXPORT wxRendererMac : public wxDelegateRendererNative
{
public:
// draw the header control button (used by wxListCtrl)
virtual int DrawHeaderButton( wxWindow *win,
wxDC& dc,
const wxRect& rect,
int flags = 0,
wxHeaderSortIconType sortArrow = wxHDR_SORT_ICON_NONE,
wxHeaderButtonParams* params = NULL );
virtual int GetHeaderButtonHeight(wxWindow *win);
// draw the expanded/collapsed icon for a tree control item
virtual void DrawTreeItemButton( wxWindow *win,
wxDC& dc,
const wxRect& rect,
int flags = 0 );
// draw a (vertical) sash
virtual void DrawSplitterSash( wxWindow *win,
wxDC& dc,
const wxSize& size,
wxCoord position,
wxOrientation orient,
int flags = 0 );
virtual void DrawCheckBox(wxWindow *win,
wxDC& dc,
const wxRect& rect,
int flags = 0);
virtual wxSize GetCheckBoxSize(wxWindow* win);
virtual void DrawComboBoxDropButton(wxWindow *win,
wxDC& dc,
const wxRect& rect,
int flags = 0);
virtual void DrawPushButton(wxWindow *win,
wxDC& dc,
const wxRect& rect,
int flags = 0);
virtual void DrawItemSelectionRect(wxWindow *win,
wxDC& dc,
const wxRect& rect,
int flags = 0);
virtual void DrawFocusRect(wxWindow* win, wxDC& dc, const wxRect& rect, int flags = 0);
virtual void DrawChoice(wxWindow* win, wxDC& dc, const wxRect& rect, int flags=0);
virtual void DrawComboBox(wxWindow* win, wxDC& dc, const wxRect& rect, int flags=0);
virtual void DrawTextCtrl(wxWindow* win, wxDC& dc, const wxRect& rect, int flags=0);
virtual void DrawRadioBitmap(wxWindow* win, wxDC& dc, const wxRect& rect, int flags=0);
#ifdef wxHAS_DRAW_TITLE_BAR_BITMAP
virtual void DrawTitleBarBitmap(wxWindow *win,
wxDC& dc,
const wxRect& rect,
wxTitleBarButton button,
int flags = 0);
#endif // wxHAS_DRAW_TITLE_BAR_BITMAP
private:
void DrawMacThemeButton(wxWindow *win,
wxDC& dc,
const wxRect& rect,
int flags,
int kind,
int adornment);
// the tree buttons
wxBitmap m_bmpTreeExpanded;
wxBitmap m_bmpTreeCollapsed;
};
// ============================================================================
// implementation
// ============================================================================
// static
wxRendererNative& wxRendererNative::GetDefault()
{
static wxRendererMac s_rendererMac;
return s_rendererMac;
}
int wxRendererMac::DrawHeaderButton( wxWindow *win,
wxDC& dc,
const wxRect& rect,
int flags,
wxHeaderSortIconType sortArrow,
wxHeaderButtonParams* params )
{
const wxCoord x = rect.x;
const wxCoord y = rect.y;
const wxCoord w = rect.width;
const wxCoord h = rect.height;
dc.SetBrush( *wxTRANSPARENT_BRUSH );
HIRect headerRect = CGRectMake( x, y, w, h );
if ( !wxInPaintEvent(win, dc) )
{
win->Refresh( &rect );
}
else
{
CGContextRef cgContext;
wxGCDCImpl *impl = (wxGCDCImpl*) dc.GetImpl();
cgContext = (CGContextRef) impl->GetGraphicsContext()->GetNativeContext();
{
HIThemeButtonDrawInfo drawInfo;
HIRect labelRect;
memset( &drawInfo, 0, sizeof(drawInfo) );
drawInfo.version = 0;
drawInfo.kind = kThemeListHeaderButton;
drawInfo.state = (flags & wxCONTROL_DISABLED) ? kThemeStateInactive : kThemeStateActive;
drawInfo.value = (flags & wxCONTROL_SELECTED) ? kThemeButtonOn : kThemeButtonOff;
drawInfo.adornment = kThemeAdornmentNone;
// The down arrow is drawn automatically, change it to an up arrow if needed.
if ( sortArrow == wxHDR_SORT_ICON_UP )
drawInfo.adornment = kThemeAdornmentHeaderButtonSortUp;
HIThemeDrawButton( &headerRect, &drawInfo, cgContext, kHIThemeOrientationNormal, &labelRect );
// If we don't want any arrows we need to draw over the one already there
if ( (flags & wxCONTROL_SELECTED) && (sortArrow == wxHDR_SORT_ICON_NONE) )
{
// clip to the header rectangle
CGContextSaveGState( cgContext );
CGContextClipToRect( cgContext, headerRect );
// but draw bigger than that so the arrow will get clipped off
headerRect.size.width += 25;
HIThemeDrawButton( &headerRect, &drawInfo, cgContext, kHIThemeOrientationNormal, &labelRect );
CGContextRestoreGState( cgContext );
}
}
}
// Reserve room for the arrows before writing the label, and turn off the
// flags we've already handled
wxRect newRect(rect);
if ( (flags & wxCONTROL_SELECTED) && (sortArrow != wxHDR_SORT_ICON_NONE) )
{
newRect.width -= 12;
sortArrow = wxHDR_SORT_ICON_NONE;
}
flags &= ~wxCONTROL_SELECTED;
return DrawHeaderButtonContents(win, dc, newRect, flags, sortArrow, params);
}
int wxRendererMac::GetHeaderButtonHeight(wxWindow* WXUNUSED(win))
{
SInt32 standardHeight;
OSStatus errStatus;
errStatus = GetThemeMetric( kThemeMetricListHeaderHeight, &standardHeight );
if (errStatus == noErr)
{
return standardHeight;
}
return -1;
}
void wxRendererMac::DrawTreeItemButton( wxWindow *win,
wxDC& dc,
const wxRect& rect,
int flags )
{
// now the wxGCDC is using native transformations
const wxCoord x = rect.x;
const wxCoord y = rect.y;
const wxCoord w = rect.width;
const wxCoord h = rect.height;
dc.SetBrush( *wxTRANSPARENT_BRUSH );
HIRect headerRect = CGRectMake( x, y, w, h );
if ( !wxInPaintEvent(win, dc) )
{
win->Refresh( &rect );
}
else
{
CGContextRef cgContext;
wxGCDCImpl *impl = (wxGCDCImpl*) dc.GetImpl();
cgContext = (CGContextRef) impl->GetGraphicsContext()->GetNativeContext();
HIThemeButtonDrawInfo drawInfo;
HIRect labelRect;
memset( &drawInfo, 0, sizeof(drawInfo) );
drawInfo.version = 0;
drawInfo.kind = kThemeDisclosureButton;
drawInfo.state = (flags & wxCONTROL_DISABLED) ? kThemeStateInactive : kThemeStateActive;
// Apple mailing list posts say to use the arrow adornment constants, but those don't work.
// We need to set the value using the 'old' DrawThemeButton constants instead.
drawInfo.value = (flags & wxCONTROL_EXPANDED) ? kThemeDisclosureDown : kThemeDisclosureRight;
drawInfo.adornment = kThemeAdornmentNone;
HIThemeDrawButton( &headerRect, &drawInfo, cgContext, kHIThemeOrientationNormal, &labelRect );
}
}
void wxRendererMac::DrawSplitterSash( wxWindow *win,
wxDC& dc,
const wxSize& size,
wxCoord position,
wxOrientation orient,
int WXUNUSED(flags) )
{
bool hasMetal = win->MacGetTopLevelWindow()->GetExtraStyle() & wxFRAME_EX_METAL;
SInt32 height;
GetThemeMetric( kThemeMetricSmallPaneSplitterHeight, &height );
HIRect splitterRect;
if (orient == wxVERTICAL)
splitterRect = CGRectMake( position, 0, height, size.y );
else
splitterRect = CGRectMake( 0, position, size.x, height );
// under compositing we should only draw when called by the OS, otherwise just issue a redraw command
// strange redraw errors occur if we don't do this
if ( !wxInPaintEvent(win, dc) )
{
wxRect rect( (int) splitterRect.origin.x, (int) splitterRect.origin.y, (int) splitterRect.size.width,
(int) splitterRect.size.height );
win->RefreshRect( rect );
}
else
{
CGContextRef cgContext;
wxGCDCImpl *impl = (wxGCDCImpl*) dc.GetImpl();
cgContext = (CGContextRef) impl->GetGraphicsContext()->GetNativeContext();
HIThemeBackgroundDrawInfo bgdrawInfo;
bgdrawInfo.version = 0;
bgdrawInfo.state = kThemeStateActive;
bgdrawInfo.kind = hasMetal ? kThemeBackgroundMetal : kThemeBackgroundPlacard;
if ( hasMetal )
HIThemeDrawBackground(&splitterRect, &bgdrawInfo, cgContext, kHIThemeOrientationNormal);
else
{
CGContextSetFillColorWithColor(cgContext,win->GetBackgroundColour().GetCGColor());
CGContextFillRect(cgContext,splitterRect);
}
HIThemeSplitterDrawInfo drawInfo;
drawInfo.version = 0;
drawInfo.state = kThemeStateActive;
drawInfo.adornment = hasMetal ? kHIThemeSplitterAdornmentMetal : kHIThemeSplitterAdornmentNone;
HIThemeDrawPaneSplitter( &splitterRect, &drawInfo, cgContext, kHIThemeOrientationNormal );
}
}
void
wxRendererMac::DrawItemSelectionRect(wxWindow * WXUNUSED(win),
wxDC& dc,
const wxRect& rect,
int flags)
{
if ( !(flags & wxCONTROL_SELECTED) )
return;
wxColour col( wxMacCreateCGColorFromHITheme( (flags & wxCONTROL_FOCUSED) ?
kThemeBrushAlternatePrimaryHighlightColor
: kThemeBrushSecondaryHighlightColor ) );
wxBrush selBrush( col );
dc.SetPen( *wxTRANSPARENT_PEN );
dc.SetBrush( selBrush );
dc.DrawRectangle( rect );
}
void
wxRendererMac::DrawMacThemeButton(wxWindow *win,
wxDC& dc,
const wxRect& rect,
int flags,
int kind,
int adornment)
{
// now the wxGCDC is using native transformations
const wxCoord x = rect.x;
const wxCoord y = rect.y;
const wxCoord w = rect.width;
const wxCoord h = rect.height;
dc.SetBrush( *wxTRANSPARENT_BRUSH );
HIRect headerRect = CGRectMake( x, y, w, h );
if ( !wxInPaintEvent(win, dc) )
{
win->Refresh( &rect );
}
else
{
wxGCDCImpl *impl = (wxGCDCImpl*) dc.GetImpl();
CGContextRef cgContext;
cgContext = (CGContextRef) impl->GetGraphicsContext()->GetNativeContext();
HIThemeButtonDrawInfo drawInfo;
HIRect labelRect;
memset( &drawInfo, 0, sizeof(drawInfo) );
drawInfo.version = 0;
drawInfo.kind = kind;
drawInfo.state = (flags & wxCONTROL_DISABLED) ? kThemeStateInactive : kThemeStateActive;
drawInfo.value = (flags & wxCONTROL_SELECTED) ? kThemeButtonOn : kThemeButtonOff;
if (flags & wxCONTROL_UNDETERMINED)
drawInfo.value = kThemeButtonMixed;
drawInfo.adornment = adornment;
if (flags & wxCONTROL_FOCUSED)
drawInfo.adornment |= kThemeAdornmentFocus;
HIThemeDrawButton( &headerRect, &drawInfo, cgContext, kHIThemeOrientationNormal, &labelRect );
}
}
void
wxRendererMac::DrawCheckBox(wxWindow *win,
wxDC& dc,
const wxRect& rect,
int flags)
{
if (flags & wxCONTROL_CHECKED)
flags |= wxCONTROL_SELECTED;
int kind;
if (win->GetWindowVariant() == wxWINDOW_VARIANT_SMALL ||
(win->GetParent() && win->GetParent()->GetWindowVariant() == wxWINDOW_VARIANT_SMALL))
kind = kThemeCheckBoxSmall;
else if (win->GetWindowVariant() == wxWINDOW_VARIANT_MINI ||
(win->GetParent() && win->GetParent()->GetWindowVariant() == wxWINDOW_VARIANT_MINI))
kind = kThemeCheckBoxMini;
else
kind = kThemeCheckBox;
DrawMacThemeButton(win, dc, rect, flags,
kind, kThemeAdornmentNone);
}
wxSize wxRendererMac::GetCheckBoxSize(wxWindow* WXUNUSED(win))
{
wxSize size;
SInt32 width, height;
OSStatus errStatus;
errStatus = GetThemeMetric(kThemeMetricCheckBoxWidth, &width);
if (errStatus == noErr)
{
size.SetWidth(width);
}
errStatus = GetThemeMetric(kThemeMetricCheckBoxHeight, &height);
if (errStatus == noErr)
{
size.SetHeight(height);
}
return size;
}
void
wxRendererMac::DrawComboBoxDropButton(wxWindow *win,
wxDC& dc,
const wxRect& rect,
int flags)
{
int kind;
if (win->GetWindowVariant() == wxWINDOW_VARIANT_SMALL || (win->GetParent() && win->GetParent()->GetWindowVariant() == wxWINDOW_VARIANT_SMALL))
kind = kThemeArrowButtonSmall;
else if (win->GetWindowVariant() == wxWINDOW_VARIANT_MINI || (win->GetParent() && win->GetParent()->GetWindowVariant() == wxWINDOW_VARIANT_MINI))
kind = kThemeArrowButtonMini;
else
kind = kThemeArrowButton;
DrawMacThemeButton(win, dc, rect, flags,
kind, kThemeAdornmentArrowDownArrow);
}
void
wxRendererMac::DrawPushButton(wxWindow *win,
wxDC& dc,
const wxRect& rect,
int flags)
{
int kind;
if (win->GetWindowVariant() == wxWINDOW_VARIANT_SMALL || (win->GetParent() && win->GetParent()->GetWindowVariant() == wxWINDOW_VARIANT_SMALL))
kind = kThemeBevelButtonSmall;
// There is no kThemeBevelButtonMini, but in this case, use Small
else if (win->GetWindowVariant() == wxWINDOW_VARIANT_MINI || (win->GetParent() && win->GetParent()->GetWindowVariant() == wxWINDOW_VARIANT_MINI))
kind = kThemeBevelButtonSmall;
else
kind = kThemeBevelButton;
DrawMacThemeButton(win, dc, rect, flags,
kind, kThemeAdornmentNone);
}
void
wxRendererMac::DrawFocusRect(wxWindow* win, wxDC& dc, const wxRect& rect, int flags)
{
if (!win)
{
wxDelegateRendererNative::DrawFocusRect(win, dc, rect, flags);
return;
}
CGRect cgrect = CGRectMake( rect.x , rect.y , rect.width, rect.height ) ;
HIThemeFrameDrawInfo info ;
memset( &info, 0 , sizeof(info) ) ;
info.version = 0 ;
info.kind = 0 ;
info.state = kThemeStateActive;
info.isFocused = true ;
CGContextRef cgContext = (CGContextRef) win->MacGetCGContextRef() ;
wxASSERT( cgContext ) ;
HIThemeDrawFocusRect( &cgrect , true , cgContext , kHIThemeOrientationNormal ) ;
}
void wxRendererMac::DrawChoice(wxWindow* win, wxDC& dc,
const wxRect& rect, int flags)
{
int kind;
if (win->GetWindowVariant() == wxWINDOW_VARIANT_SMALL ||
(win->GetParent() && win->GetParent()->GetWindowVariant() == wxWINDOW_VARIANT_SMALL))
kind = kThemePopupButtonSmall;
else if (win->GetWindowVariant() == wxWINDOW_VARIANT_MINI ||
(win->GetParent() && win->GetParent()->GetWindowVariant() == wxWINDOW_VARIANT_MINI))
kind = kThemePopupButtonMini;
else
kind = kThemePopupButton;
DrawMacThemeButton(win, dc, rect, flags, kind, kThemeAdornmentNone);
}
void wxRendererMac::DrawComboBox(wxWindow* win, wxDC& dc,
const wxRect& rect, int flags)
{
int kind;
if (win->GetWindowVariant() == wxWINDOW_VARIANT_SMALL ||
(win->GetParent() && win->GetParent()->GetWindowVariant() == wxWINDOW_VARIANT_SMALL))
kind = kThemeComboBoxSmall;
else if (win->GetWindowVariant() == wxWINDOW_VARIANT_MINI ||
(win->GetParent() && win->GetParent()->GetWindowVariant() == wxWINDOW_VARIANT_MINI))
kind = kThemeComboBoxMini;
else
kind = kThemeComboBox;
DrawMacThemeButton(win, dc, rect, flags, kind, kThemeAdornmentNone);
}
void wxRendererMac::DrawRadioBitmap(wxWindow* win, wxDC& dc,
const wxRect& rect, int flags)
{
int kind;
if (win->GetWindowVariant() == wxWINDOW_VARIANT_SMALL ||
(win->GetParent() && win->GetParent()->GetWindowVariant() == wxWINDOW_VARIANT_SMALL))
kind = kThemeRadioButtonSmall;
else if (win->GetWindowVariant() == wxWINDOW_VARIANT_MINI ||
(win->GetParent() && win->GetParent()->GetWindowVariant() == wxWINDOW_VARIANT_MINI))
kind = kThemeRadioButtonMini;
else
kind = kThemeRadioButton;
if (flags & wxCONTROL_CHECKED)
flags |= wxCONTROL_SELECTED;
DrawMacThemeButton(win, dc, rect, flags,
kind, kThemeAdornmentNone);
}
void wxRendererMac::DrawTextCtrl(wxWindow* win, wxDC& dc,
const wxRect& rect, int flags)
{
const wxCoord x = rect.x;
const wxCoord y = rect.y;
const wxCoord w = rect.width;
const wxCoord h = rect.height;
dc.SetBrush( *wxWHITE_BRUSH );
dc.SetPen( *wxTRANSPARENT_PEN );
dc.DrawRectangle(rect);
dc.SetBrush( *wxTRANSPARENT_BRUSH );
HIRect hiRect = CGRectMake( x, y, w, h );
if ( !wxInPaintEvent(win, dc) )
{
win->Refresh( &rect );
}
else
{
CGContextRef cgContext;
cgContext = (CGContextRef) static_cast<wxGCDCImpl*>(dc.GetImpl())->GetGraphicsContext()->GetNativeContext();
{
HIThemeFrameDrawInfo drawInfo;
memset( &drawInfo, 0, sizeof(drawInfo) );
drawInfo.version = 0;
drawInfo.kind = kHIThemeFrameTextFieldSquare;
drawInfo.state = (flags & wxCONTROL_DISABLED) ? kThemeStateInactive : kThemeStateActive;
if (flags & wxCONTROL_FOCUSED)
drawInfo.isFocused = true;
HIThemeDrawFrame( &hiRect, &drawInfo, cgContext, kHIThemeOrientationNormal);
}
}
}
#ifdef wxHAS_DRAW_TITLE_BAR_BITMAP
void wxRendererMac::DrawTitleBarBitmap(wxWindow *win,
wxDC& dc,
const wxRect& rect,
wxTitleBarButton button,
int flags)
{
// the files below were converted from the originals in art/osx/close*.png
// using misc/scripts/png2c.py script -- we must use PNG and not XPM for
// them because they use transparency and don't look right without it
/* close.png - 400 bytes */
static const unsigned char close_png[] = {
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a,
0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x0e,
0x08, 0x06, 0x00, 0x00, 0x00, 0x1f, 0x48, 0x2d,
0xd1, 0x00, 0x00, 0x00, 0x06, 0x62, 0x4b, 0x47,
0x44, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0xa0,
0xbd, 0xa7, 0x93, 0x00, 0x00, 0x00, 0x09, 0x70,
0x48, 0x59, 0x73, 0x00, 0x00, 0x0b, 0x12, 0x00,
0x00, 0x0b, 0x12, 0x01, 0xd2, 0xdd, 0x7e, 0xfc,
0x00, 0x00, 0x00, 0x09, 0x76, 0x70, 0x41, 0x67,
0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x0e,
0x00, 0xb1, 0x5b, 0xf1, 0xf7, 0x00, 0x00, 0x00,
0xef, 0x49, 0x44, 0x41, 0x54, 0x28, 0xcf, 0xa5,
0xd2, 0x31, 0x4a, 0x03, 0x41, 0x18, 0xc5, 0xf1,
0xdf, 0xc6, 0x55, 0x02, 0xb2, 0x18, 0xb0, 0x33,
0x8d, 0xd8, 0x6e, 0x8a, 0x14, 0xa6, 0xb2, 0xc9,
0x21, 0x72, 0x0b, 0xdb, 0x5c, 0x45, 0x98, 0x3b,
0x24, 0xc7, 0x99, 0x6d, 0x2d, 0x04, 0xd3, 0x09,
0x42, 0x48, 0x65, 0x60, 0x6c, 0x76, 0x65, 0x1c,
0x14, 0x45, 0x5f, 0x35, 0xfc, 0xe7, 0x3d, 0xe6,
0x9b, 0x8f, 0x57, 0xf9, 0xac, 0x06, 0x97, 0x98,
0xe0, 0xbc, 0x67, 0x07, 0xbc, 0xe2, 0x05, 0xfb,
0xc1, 0x58, 0x65, 0xa1, 0x2b, 0x4c, 0xb3, 0x40,
0xa9, 0x03, 0x9e, 0xb1, 0x83, 0x93, 0x2c, 0x74,
0x83, 0xb1, 0xef, 0x75, 0x86, 0x0b, 0x1c, 0xb1,
0x1f, 0xf5, 0xe3, 0x4d, 0x51, 0x43, 0x08, 0xe1,
0xb6, 0x4c, 0x64, 0xac, 0xee, 0xbd, 0x0d, 0x5c,
0x63, 0x89, 0x65, 0x08, 0x61, 0x9d, 0x52, 0x4a,
0x31, 0xc6, 0xcd, 0xc0, 0x62, 0x8c, 0x9b, 0x94,
0x52, 0x0a, 0x21, 0xac, 0x07, 0xd6, 0x67, 0xcc,
0x33, 0xf0, 0x61, 0x8c, 0x31, 0x6e, 0xf2, 0x73,
0xee, 0xc1, 0xbc, 0xc2, 0x1d, 0x4e, 0xf3, 0xd1,
0x62, 0x8c, 0xf7, 0x6d, 0xdb, 0xae, 0xa0, 0xeb,
0xba, 0xed, 0x6c, 0x36, 0x7b, 0x28, 0xa6, 0x7f,
0x1b, 0xf9, 0xa3, 0xea, 0x7e, 0xcd, 0x93, 0xf2,
0xb5, 0xae, 0xeb, 0xb6, 0xd0, 0xb6, 0xed, 0x2a,
0xc6, 0xa8, 0x78, 0xf5, 0xf0, 0xaf, 0xe5, 0x34,
0x58, 0xe4, 0xe1, 0x62, 0x11, 0x25, 0x5b, 0xa0,
0x19, 0x9a, 0x33, 0x14, 0xa0, 0xfe, 0xe1, 0x6b,
0x47, 0x3c, 0x62, 0x37, 0x34, 0x67, 0xdf, 0xc3,
0x71, 0xdf, 0x90, 0xaf, 0x74, 0xc0, 0x93, 0xbe,
0x72, 0x55, 0x71, 0xf9, 0xeb, 0x92, 0xbf, 0x03,
0x70, 0x33, 0x76, 0x58, 0xe5, 0x41, 0xfb, 0x6d,
0x00, 0x00, 0x00, 0x20, 0x7a, 0x54, 0x58, 0x74,
0x74, 0x69, 0x66, 0x66, 0x3a, 0x72, 0x6f, 0x77,
0x73, 0x2d, 0x70, 0x65, 0x72, 0x2d, 0x73, 0x74,
0x72, 0x69, 0x70, 0x00, 0x00, 0x78, 0xda, 0x33,
0xb5, 0x30, 0x05, 0x00, 0x01, 0x47, 0x00, 0xa3,
0x38, 0xda, 0x77, 0x3b, 0x00, 0x00, 0x00, 0x00,
0x49, 0x45, 0x4e, 0x44, 0xae, 0x42, 0x60, 0x82
};
/* close_current.png - 421 bytes */
static const unsigned char close_current_png[] = {
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a,
0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x0e,
0x08, 0x06, 0x00, 0x00, 0x00, 0x1f, 0x48, 0x2d,
0xd1, 0x00, 0x00, 0x00, 0x06, 0x62, 0x4b, 0x47,
0x44, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0xa0,
0xbd, 0xa7, 0x93, 0x00, 0x00, 0x00, 0x09, 0x70,
0x48, 0x59, 0x73, 0x00, 0x00, 0x0b, 0x12, 0x00,
0x00, 0x0b, 0x12, 0x01, 0xd2, 0xdd, 0x7e, 0xfc,
0x00, 0x00, 0x00, 0x09, 0x76, 0x70, 0x41, 0x67,
0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x0e,
0x00, 0xb1, 0x5b, 0xf1, 0xf7, 0x00, 0x00, 0x01,
0x04, 0x49, 0x44, 0x41, 0x54, 0x28, 0xcf, 0x9d,
0xd2, 0xbd, 0x4a, 0x43, 0x31, 0x00, 0xc5, 0xf1,
0xdf, 0x8d, 0x56, 0x44, 0x04, 0x45, 0xd0, 0xc5,
0x55, 0xdc, 0x0a, 0x8e, 0xed, 0xec, 0xe4, 0xec,
0x24, 0xd4, 0x67, 0x29, 0x59, 0xfa, 0x16, 0x9d,
0x7c, 0x07, 0x1d, 0x5c, 0xba, 0xa5, 0xa3, 0x28,
0x22, 0x94, 0xae, 0x2e, 0x1d, 0x4a, 0x5d, 0x55,
0xb8, 0x2e, 0x09, 0x5c, 0x4b, 0xfd, 0xa0, 0x67,
0x0a, 0x27, 0x39, 0xc9, 0x49, 0xf2, 0xaf, 0x7c,
0xd7, 0x01, 0x8e, 0x71, 0x84, 0xfd, 0xec, 0x2d,
0x30, 0xc3, 0x2b, 0xe6, 0x65, 0x61, 0xd5, 0x08,
0x9d, 0xe0, 0x14, 0x7b, 0x56, 0xeb, 0x0d, 0x13,
0x4c, 0x61, 0xa3, 0x11, 0x3a, 0xc3, 0x8e, 0x9f,
0xb5, 0x9d, 0x9b, 0xbc, 0x63, 0x1e, 0x72, 0xbd,
0x53, 0xb4, 0x20, 0xc6, 0xd8, 0x5e, 0x4e, 0x34,
0xbc, 0x56, 0x5e, 0x7b, 0x00, 0x6d, 0x5c, 0xe1,
0x2a, 0xc6, 0x38, 0xa8, 0xeb, 0xba, 0x4e, 0x29,
0xdd, 0x16, 0x2f, 0xa5, 0x74, 0x5b, 0xd7, 0x75,
0x1d, 0x63, 0x1c, 0x14, 0x0f, 0xed, 0x0a, 0xe7,
0xb9, 0x02, 0x48, 0x29, 0x5d, 0x77, 0x3a, 0x9d,
0x8b, 0xf1, 0x78, 0x7c, 0x07, 0x65, 0xdc, 0xed,
0x76, 0x6f, 0x1a, 0x25, 0x66, 0x15, 0x2e, 0xb1,
0xd5, 0xac, 0x56, 0xc2, 0xb0, 0x22, 0x04, 0xef,
0xc1, 0x9a, 0xda, 0xcc, 0xff, 0xf4, 0x6b, 0xd5,
0x94, 0x92, 0xa5, 0x53, 0x17, 0x6b, 0x3f, 0xce,
0x06, 0x3e, 0x71, 0x88, 0xed, 0xd1, 0x68, 0x34,
0x0b, 0x21, 0x4c, 0x7a, 0xbd, 0xde, 0x7d, 0xd9,
0x7a, 0x38, 0x1c, 0x3e, 0x86, 0x10, 0x26, 0xfd,
0x7e, 0xff, 0xa9, 0x01, 0xc2, 0x4b, 0x21, 0xa7,
0x00, 0xd0, 0xfa, 0xe3, 0x6a, 0x1f, 0x78, 0xc0,
0xb4, 0x90, 0x33, 0xcf, 0x44, 0xec, 0x66, 0x42,
0x56, 0xe9, 0x0d, 0xcf, 0x32, 0x72, 0xd5, 0xd2,
0xe4, 0xbf, 0x21, 0xff, 0x02, 0x4d, 0xb5, 0x74,
0x79, 0x60, 0x9f, 0x78, 0x78, 0x00, 0x00, 0x00,
0x20, 0x7a, 0x54, 0x58, 0x74, 0x74, 0x69, 0x66,
0x66, 0x3a, 0x72, 0x6f, 0x77, 0x73, 0x2d, 0x70,
0x65, 0x72, 0x2d, 0x73, 0x74, 0x72, 0x69, 0x70,
0x00, 0x00, 0x78, 0xda, 0x33, 0xb5, 0x30, 0x05,
0x00, 0x01, 0x47, 0x00, 0xa3, 0x38, 0xda, 0x77,
0x3b, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4e,
0x44, 0xae, 0x42, 0x60, 0x82};
/* close_pressed.png - 458 bytes */
static const unsigned char close_pressed_png[] = {
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a,
0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x0e,
0x08, 0x06, 0x00, 0x00, 0x00, 0x1f, 0x48, 0x2d,
0xd1, 0x00, 0x00, 0x00, 0x06, 0x62, 0x4b, 0x47,
0x44, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0xa0,
0xbd, 0xa7, 0x93, 0x00, 0x00, 0x00, 0x09, 0x70,
0x48, 0x59, 0x73, 0x00, 0x00, 0x0b, 0x12, 0x00,
0x00, 0x0b, 0x12, 0x01, 0xd2, 0xdd, 0x7e, 0xfc,
0x00, 0x00, 0x00, 0x09, 0x76, 0x70, 0x41, 0x67,
0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x0e,
0x00, 0xb1, 0x5b, 0xf1, 0xf7, 0x00, 0x00, 0x01,
0x29, 0x49, 0x44, 0x41, 0x54, 0x28, 0xcf, 0x9d,
0x92, 0x31, 0x6a, 0xc3, 0x40, 0x14, 0x44, 0x9f,
0x2c, 0xe1, 0xc2, 0x10, 0x08, 0xc4, 0xe0, 0x22,
0x76, 0x21, 0x04, 0x29, 0x13, 0xf0, 0x05, 0x54,
0xa5, 0x8a, 0x0f, 0xb2, 0x8d, 0x0e, 0xa0, 0x23,
0xa8, 0x56, 0xa3, 0x03, 0xe8, 0x08, 0xba, 0x80,
0xba, 0xb0, 0x45, 0x0a, 0x97, 0x02, 0x23, 0x58,
0x83, 0x40, 0x60, 0x61, 0x08, 0x11, 0x04, 0x57,
0x69, 0xf6, 0xc3, 0x46, 0x38, 0x24, 0x64, 0xca,
0xd9, 0x19, 0xe6, 0xff, 0xfd, 0xe3, 0xf1, 0x1d,
0x2b, 0x20, 0x02, 0x36, 0xc0, 0xd2, 0x72, 0x27,
0xe0, 0x08, 0x1c, 0x80, 0x5e, 0x84, 0x9e, 0x63,
0x7a, 0x04, 0xb6, 0xc0, 0x1d, 0xd7, 0x31, 0x00,
0x6f, 0xc0, 0x1e, 0xc0, 0x77, 0x4c, 0x31, 0x70,
0xc3, 0xcf, 0x58, 0xd8, 0x49, 0x3e, 0x81, 0x7e,
0x66, 0xc7, 0xdb, 0x02, 0x73, 0x80, 0xdd, 0x6e,
0xb7, 0x9a, 0x3a, 0x1c, 0x6e, 0x6e, 0xb5, 0x2b,
0x1f, 0x78, 0x02, 0x1e, 0x44, 0x90, 0x65, 0xd9,
0x8b, 0xef, 0xfb, 0xef, 0x5a, 0xeb, 0x33, 0x40,
0x92, 0x24, 0x51, 0x9a, 0xa6, 0xcf, 0xc6, 0x98,
0xae, 0x69, 0x9a, 0xd1, 0x26, 0x8f, 0x81, 0x8d,
0x07, 0xa0, 0xaa, 0xaa, 0x3e, 0x0c, 0xc3, 0x5a,
0x29, 0x15, 0x0b, 0xa7, 0x94, 0x8a, 0x8b, 0xa2,
0xa8, 0xab, 0xaa, 0xea, 0x9d, 0x21, 0x36, 0x81,
0xf3, 0x7b, 0x00, 0xe4, 0x79, 0x7e, 0x10, 0x03,
0x40, 0x51, 0x14, 0xb5, 0x70, 0x0e, 0x96, 0x33,
0xfe, 0x89, 0xc0, 0xde, 0x69, 0x2d, 0x44, 0x92,
0x24, 0x91, 0x8c, 0xe7, 0x26, 0x4f, 0x52, 0x4f,
0x81, 0x3d, 0xee, 0x5a, 0x3e, 0x47, 0x4c, 0xae,
0x50, 0x29, 0x15, 0xb7, 0x6d, 0xfb, 0xe1, 0xec,
0x79, 0xf4, 0x81, 0x0b, 0x70, 0x0f, 0x2c, 0x9a,
0xa6, 0x19, 0x8d, 0x31, 0x5d, 0x59, 0x96, 0x47,
0x31, 0x69, 0xad, 0xcf, 0xc6, 0x98, 0xce, 0x31,
0x0d, 0x80, 0x96, 0xe6, 0x48, 0x01, 0xe6, 0xbf,
0xac, 0x76, 0x01, 0x6a, 0x60, 0x2f, 0xcd, 0xe9,
0x6d, 0x23, 0x6e, 0xed, 0x9d, 0xae, 0x61, 0x00,
0x5e, 0xb1, 0x95, 0xf3, 0x26, 0x8f, 0x7f, 0x2e,
0xf9, 0x17, 0x50, 0x59, 0x74, 0x13, 0x34, 0x41,
0x04, 0x5a, 0x00, 0x00, 0x00, 0x20, 0x7a, 0x54,
0x58, 0x74, 0x74, 0x69, 0x66, 0x66, 0x3a, 0x72,
0x6f, 0x77, 0x73, 0x2d, 0x70, 0x65, 0x72, 0x2d,
0x73, 0x74, 0x72, 0x69, 0x70, 0x00, 0x00, 0x78,
0xda, 0x33, 0xb5, 0x30, 0x05, 0x00, 0x01, 0x47,
0x00, 0xa3, 0x38, 0xda, 0x77, 0x3b, 0x00, 0x00,
0x00, 0x00, 0x49, 0x45, 0x4e, 0x44, 0xae, 0x42,
0x60, 0x82};
// currently we only support the close bitmap here
if ( button != wxTITLEBAR_BUTTON_CLOSE )
{
m_rendererNative.DrawTitleBarBitmap(win, dc, rect, button, flags);
return;
}
// choose the correct image depending on flags
const void *data;
size_t len;
if ( flags & wxCONTROL_PRESSED )
{
data = close_pressed_png;
len = WXSIZEOF(close_pressed_png);
}
else if ( flags & wxCONTROL_CURRENT )
{
data = close_current_png;
len = WXSIZEOF(close_current_png);
}
else
{
data = close_png;
len = WXSIZEOF(close_png);
}
// load it
wxMemoryInputStream mis(data, len);
wxImage image(mis, wxBITMAP_TYPE_PNG);
wxBitmap bmp(image);
wxASSERT_MSG( bmp.IsOk(), "failed to load embedded PNG image?" );
// and draw it centering it in the provided rectangle: we don't scale the
// image because this is really not going to look good for such a small
// (14*14) bitmap
dc.DrawBitmap(bmp, wxRect(bmp.GetSize()).CenterIn(rect).GetPosition());
}
#endif // wxHAS_DRAW_TITLE_BAR_BITMAP
#endif | [
"esrrhs@esrrhs-PC"
] | esrrhs@esrrhs-PC |
9201413fac0a99bdab3dd41bcfafd5a7d8d7a8f4 | ba3df81b4e61a7963240321295c0684b5a38d0f1 | /model/fib/ndn-fib.h | a92a573fe4d5d98a9216e8a458e38ad1b57fcc0d | [] | no_license | manseu/ns-3-ndnSIM-Modification | 9803326a4207047733c3cad6ae8a978a518b01f4 | c22ab1e867584020dc023cc5c0c7f61560599d05 | refs/heads/master | 2021-01-19T06:32:36.945348 | 2012-12-08T06:02:15 | 2012-12-08T06:02:15 | 6,573,112 | 2 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 5,222 | h | /* -*- Mode: C++; c-file-style: "gnu"; indent-tabs-mode:nil -*- */
/*
* Copyright (c) 2011 University of California, Los Angeles
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation;
*
* 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
*
* Author: Alexander Afanasyev <alexander.afanasyev@ucla.edu>
*/
#ifndef _NDN_FIB_H_
#define _NDN_FIB_H_
#include "ns3/simple-ref-count.h"
#include "ns3/node.h"
#include "ns3/ndn-fib-entry.h"
namespace ns3 {
namespace ndn {
class InterestHeader;
/**
* \ingroup ndn
* \brief Class implementing FIB functionality
*/
class Fib : public Object
{
public:
/**
* \brief Interface ID
*
* \return interface ID
*/
static TypeId GetTypeId ();
/**
* @brief Default constructor
*/
Fib () {}
/**
* @brief Virtual destructor
*/
virtual ~Fib () { };
/**
* \brief Perform longest prefix match
*
* \todo Implement exclude filters
*
* \param interest Interest packet header
* \returns If entry found a valid iterator will be returned, otherwise end ()
*/
virtual Ptr<fib::Entry>
LongestPrefixMatch (const InterestHeader &interest) = 0;
virtual Ptr<fib::Entry>
LongestPrefixMatchOfLocator (const InterestHeader &interest) = 0;
/**
* \brief Add or update FIB entry
*
* If the entry exists, metric will be updated. Otherwise, new entry will be created
*
* Entries in FIB never deleted. They can be invalidated with metric==NETWORK_UNREACHABLE
*
* @param name Prefix
* @param face Forwarding face
* @param metric Routing metric
*/
virtual Ptr<fib::Entry>
Add (const NameComponents &prefix, Ptr<Face> face, int32_t metric) = 0;
/**
* \brief Add or update FIB entry using smart pointer to prefix
*
* If the entry exists, metric will be updated. Otherwise, new entry will be created
*
* Entries in FIB never deleted. They can be invalidated with metric==NETWORK_UNREACHABLE
*
* @param name Smart pointer to prefix
* @param face Forwarding face
* @param metric Routing metric
*/
virtual Ptr<fib::Entry>
Add (const Ptr<const NameComponents> &prefix, Ptr<Face> face, int32_t metric) = 0;
/**
* @brief Remove FIB entry
*
* ! ATTENTION ! Use with caution. All PIT entries referencing the corresponding FIB entry will become invalid.
* So, simulation may crash.
*
* @param name Smart pointer to prefix
*/
virtual void
Remove (const Ptr<const NameComponents> &prefix) = 0;
// /**
// * @brief Invalidate FIB entry ("Safe" version of Remove)
// *
// * All faces for the entry will be assigned maximum routing metric and NDN_FIB_RED status
// * @param name Smart pointer to prefix
// */
// virtual void
// Invalidate (const Ptr<const NameComponents> &prefix) = 0;
/**
* @brief Invalidate all FIB entries
*/
virtual void
InvalidateAll () = 0;
/**
* @brief Remove all references to a face from FIB. If for some enty that face was the only element,
* this FIB entry will be removed.
*/
virtual void
RemoveFromAll (Ptr<Face> face) = 0;
/**
* @brief Print out entries in FIB
*/
virtual void
Print (std::ostream &os) const = 0;
/**
* @brief Get number of entries in FIB
*/
virtual uint32_t
GetSize () const = 0;
/**
* @brief Return first element of FIB (no order guaranteed)
*/
virtual Ptr<const fib::Entry>
Begin () = 0;
/**
* @brief Return item next after last (no order guaranteed)
*/
virtual Ptr<const fib::Entry>
End () = 0;
/**
* @brief Advance the iterator
*/
virtual Ptr<const fib::Entry>
Next (Ptr<const fib::Entry>) = 0;
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
/**
* @brief Static call to cheat python bindings
*/
static inline Ptr<Fib>
GetFib (Ptr<Object> node);
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
private:
Fib (const Fib&) {} ; ///< \brief copy constructor is disabled
};
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
std::ostream& operator<< (std::ostream& os, const Fib &fib);
Ptr<Fib>
Fib::GetFib (Ptr<Object> node)
{
return node->GetObject<Fib> ();
}
} // namespace ndn
} // namespace ns3
#endif // _NDN_FIB_H_
| [
"tomy_ip@live.com"
] | tomy_ip@live.com |
f6c5056d4eb1e8c10c4b35a6ad27fe05e6bdd5f9 | bb1d227d516aa2316c2c97d9f844e03584e0b0bf | /backend/src/movie/movie.hpp | 2a68fbebcd2b07a6829d0d83a20657a8fbbabe0f | [] | no_license | phymod0/yify-home | c9c3bf31fa8e3b81377e3367656dc13e790cf8d3 | c3377972a2573f31bf2a9cdeec62c708a5ef3e12 | refs/heads/master | 2020-05-27T14:49:18.319423 | 2019-08-03T22:36:35 | 2019-08-03T22:36:35 | 188,668,386 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,227 | hpp | #ifndef MOVIE
#define MOVIE
#include <stdio.h>
#include <stdint.h>
#include "../cpp_compat/pair.hpp"
#include "../cpp_compat/string.hpp"
class Movie {
public:
enum class Genre {
Horror,
Action,
Mystery,
Drama,
SciFi,
Thriller,
Romance,
Comedy,
Adventure,
Unregistered,
};
class GenreSet {
uint32_t gBitfield;
Genre gCode(const char* gStr) const;
const char* gStr(Genre gCode) const;
public:
class iterator {
friend class GenreSet;
int currentBit;
const GenreSet& gs;
public:
iterator(const GenreSet& gs);
const char* operator*() const;
iterator& operator++();
bool operator!=(const iterator& it) const;
bool operator==(const iterator& it) const;
};
GenreSet();
void include(Genre g);
void include(const char* gStr);
void include(const string& gStr);
void remove(Genre g);
void remove(const char* gStr);
void remove(const string& gStr);
bool empty() const;
bool matches(const Movie& m) const;
iterator begin() const;
iterator end() const;
};
class Criteria {
GenreSet genres, blacklist;
float minRating, maxRating;
int minReleaseYear, maxReleaseYear;
int minUploadYear, maxUploadYear;
public:
Criteria();
void allowGenre(Genre g);
void blacklistGenre(Genre g);
void setMinRating(float rating);
void setMaxRating(float rating);
void setMinReleaseYear(int year);
void setMaxReleaseYear(int year);
void setMinUploadYear(int year);
void setMaxUploadYear(int year);
bool contains(const Movie& m) const;
};
class Order {
public:
typedef enum {
Rating,
UploadYear,
ReleaseYear,
} Type;
typedef enum {
Ascending,
Irrelevant,
Descending,
} Weight;
typedef pair<Type,Weight> priority;
Order();
void prioritize(Type t, Weight w);
void prioritize(const priority& p);
int operator()(const Movie& m1, const Movie& m2) const;
int compare(const Movie& m1, const Movie& m2) const;
private:
priority priorities[3];
};
Movie();
Movie(const char* jsonData, size_t len);
string getTitle() const;
int getYtsId() const;
string serialize() const;
private:
string imgLink, title;
int ytsId;
GenreSet genres;
float rating;
int releaseYear, uploadYear;
};
#endif /* MOVIE */
| [
"chishtiawais511@gmail.com"
] | chishtiawais511@gmail.com |
fe27fbfd4955ee762d25d7946fb8e97b693a9127 | c8b39acfd4a857dc15ed3375e0d93e75fa3f1f64 | /Engine/Plugins/FX/Niagara/Source/Niagara/Public/NiagaraMeshRendererProperties.h | c41def5ace646dddbf3555b1f5f6268c2711b66c | [
"MIT",
"LicenseRef-scancode-proprietary-license"
] | permissive | windystrife/UnrealEngine_NVIDIAGameWorks | c3c7863083653caf1bc67d3ef104fb4b9f302e2a | b50e6338a7c5b26374d66306ebc7807541ff815e | refs/heads/4.18-GameWorks | 2023-03-11T02:50:08.471040 | 2022-01-13T20:50:29 | 2022-01-13T20:50:29 | 124,100,479 | 262 | 179 | MIT | 2022-12-16T05:36:38 | 2018-03-06T15:44:09 | C++ | UTF-8 | C++ | false | false | 1,169 | h | // Copyright 1998-2017 Epic Games, Inc. All Rights Reserved.
#pragma once
#include "CoreMinimal.h"
#include "UObject/ObjectMacros.h"
#include "NiagaraRendererProperties.h"
#include "StaticMeshResources.h"
#include "NiagaraMeshRendererProperties.generated.h"
UCLASS(editinlinenew)
class UNiagaraMeshRendererProperties : public UNiagaraRendererProperties
{
public:
GENERATED_BODY()
UNiagaraMeshRendererProperties();
//~ UNiagaraRendererProperties interface
virtual NiagaraRenderer* CreateEmitterRenderer(ERHIFeatureLevel::Type FeatureLevel) override;
virtual void GetUsedMaterials(TArray<UMaterialInterface*>& OutMaterials) const override;
#if WITH_EDITORONLY_DATA
virtual bool IsMaterialValidForRenderer(UMaterial* Material, FText& InvalidMessage) override;
virtual void FixMaterial(UMaterial* Material) override;
virtual const TArray<FNiagaraVariable>& GetRequiredAttributes() override;
virtual const TArray<FNiagaraVariable>& GetOptionalAttributes() override;
#endif // WITH_EDITORONLY_DATA
void PostEditChangeProperty(FPropertyChangedEvent& PropertyChangedEvent);
UPROPERTY(EditAnywhere, Category = "Mesh Rendering")
UStaticMesh *ParticleMesh;
};
| [
"tungnt.rec@gmail.com"
] | tungnt.rec@gmail.com |
c70e52b6691ccf87aa7ba979ed4334cb4f464647 | d4843d73dc21853e900b0cc03c31610b01a67de6 | /PressureSensor.h | f1b92f4bf218cd2638ac47bb501d7020eb846f33 | [] | no_license | derlin/FreeHugBern-Arduino | 44bcaf9e42a8d0f47e2699da597642e0e4afe0ee | 2e242babf5e03697d4d01e9c52fbe9c370311091 | refs/heads/master | 2021-01-10T11:56:06.808301 | 2015-12-15T18:26:44 | 2015-12-15T18:26:44 | 48,059,657 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 554 | h | #ifndef PRESSURE_SENSOR
#define PRESSURE_SENSOR
#include <Arduino.h>
#include "Streaming.h"
// #define HUGGI_PRESSURE_SENSOR_DEBUG
#define MAX_SAMPLES 4 // samples for calibation
#define DEFAULT_SENSITIVITY 0.65
typedef struct {
int pin;
int refValue;
} SInput;
class PressureSensor
{
public:
PressureSensor(int *, int);
bool isPressed();
void setSensitivity(double);
void calibrate();
private:
int nbrOfInputs;
double sensitivity;
SInput * inputs;
};
#endif | [
"lucy.derlin@gmail.com"
] | lucy.derlin@gmail.com |
d1d6f5c837baea7bfb805e02d99c1fde82f0c2e0 | 41bdf6e0f36b1e950edf923e1a6fa7e18a656551 | /Source/Modules/Graphics/Shader.cpp | afc21539fffb7f507528e06a5d7410492b70f0bd | [
"MIT"
] | permissive | crystalboxesprivate/shingine | 129103e8ac3ec68b3fb3ecce7c80690c6fec29b9 | a6dfc5b6de1bbe7a7c4985baa91571a4d08b6cdd | refs/heads/master | 2020-11-30T00:28:05.123899 | 2018-11-07T10:56:54 | 2018-11-07T10:56:54 | 230,251,757 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 774 | cpp | #include "Modules/Graphics/Shader.h"
#include "Modules/Statics/IAssetManager.h"
REGISTER_SERIALIZED_CLASS(ShaderSource)
REGISTER_SERIALIZED_CLASS(Shader)
void Shader::AddSource(EShaderType type, const String &source) {
String garbage;
if (GetSource(type, garbage))
return;
ShaderSource *shaderSource =
Statics::Get<IAssetManager>()->AddAssetOfType<ShaderSource>();
shaderSource->Type = type;
shaderSource->Source = source;
Source.push_back(shaderSource);
}
bool Shader::GetSource(EShaderType type, String &source) {
for (size_t x = 0; x < Source.size(); x++) {
if (Source[x]->Type == (unsigned int)type) {
source = Source[x]->Source;
return true;
}
}
return false;
}
unsigned int Shader::AssetId() { return UniqueID(); }
| [
"ursus95@gmail.com"
] | ursus95@gmail.com |
c3c01385c5178066596985abc72605a2a834aee9 | fdc8fa79fec885e7a6769af8bddd164ce1246958 | /Lab2_KNN+NB/DATA/NB_classification.cpp | 0cf059de7a847b786a798c77de23c7c4bd67dbb9 | [] | no_license | hansx7/AI | 002844088f8fc16b3b9de603df591d3b8a87bf5f | 02ed51dbe355f3fb17494222048916a69f6c0e14 | refs/heads/master | 2021-04-27T00:23:01.140721 | 2018-04-24T18:57:22 | 2018-04-24T18:57:22 | 123,803,014 | 0 | 0 | null | null | null | null | GB18030 | C++ | false | false | 5,401 | cpp | #include <iostream>
#include <fstream>
#include <cstdio>
#include <iomanip>
#include <string.h>
#include <stdio.h>
#include <cstring>
#include <cmath>
#include <algorithm>
#include <set>
using namespace std;
struct emotion {
string es;
int ne, nw, ve; //文本个数、单词总数和不重复单词总数
string ewords[10000];
};
int num, txt1, txt2; //分别是不同的单词总数，训练集、验证集和测试集句子数
int ori[1500][15000]; //原始的单词统计矩阵。其中第0行表示每个单词在多少个文本中出现过（算idf用），第0列表示每句话有多少个单词（算tf用）
int nwe[6][15000]; //每个单词在不同标签中出现次数
string words[15000]; //按照出现顺序记录每一个单词
string label[1500]; //记录训练集中每个文本的label和验证集的答案
int k, cnt, emod;
emotion em[6];
int search(char *p) //在出现过的单词中搜索，如果是旧单词就返回位置，否则返回-1表示是新单词
{
for (int i = 1; i <= num; i++)
{
if (words[i] == p) return i;
}
return -1;
}
int search2(char *p)
{
for (int i = 0; i < em[emod].nw; i++)
{
if (em[emod].ewords[i] == p) return i;
}
return -1;
}
int emorder(string emo)
{
if (emo == "anger") return 0;
else if (emo == "disgust") return 1;
else if (emo == "fear") return 2;
else if (emo == "joy") return 3;
else if (emo == "sad") return 4;
else if (emo == "surprise") return 5;
}
int main()
{
ifstream trainin("train_set.csv");
ifstream validationin("validation_set.csv");
ifstream testin("test_set.csv");
ofstream res("res.csv");
if (!trainin)
{
cout << "404!\n";
return 0;
}
em[0].es = "anger";
em[1].es = "disgust";
em[2].es = "fear";
em[3].es = "joy";
em[4].es = "sad";
em[5].es = "surprise";
for (int i = 0; i<6; i++)
em[i].ne = em[i].nw = em[i].ve = 0;
memset(nwe, 0, sizeof(nwe));
char s[500];
num = txt1 = txt2 = 0;
memset(ori, 0, sizeof(ori));
trainin.getline(s, 500);
while (!trainin.eof())
{
trainin.getline(s, 500);
txt1++;
string ss = s;
int comma = ss.find(",", 0);
if (comma < string::npos)
{
label[txt1] = ss.substr(comma + 1, ss.length() - comma - 1);
emod = emorder(label[txt1]);
em[emod].ne++;
s[comma] = '\0';
}
const char *d = " ";
char *p;
p = strtok(s, d);
while (p) //这个while循环用来分词
{
int pos = search(p); //判断是新词还是旧词并做不同处理
em[emod].nw++;
if (pos>0) //这是一个旧单词
{
nwe[emod][pos]++; //原位置加一即可
}
else
{
num++; //新单词要新开位置
nwe[emod][num]++;
words[num] = p;
}
if (search2(p)<0)
{ //标签中的新单词要记录下来
em[emod].ewords[em[emod].ve] = p;
em[emod].ve++;
}
p = strtok(NULL, d); //分出下一个单词，81行和58行一起分词
}
}
txt1--; //每次都会多统计一个文本，所以做完之后要减一
cnt = 0;
validationin.getline(s, 500);
while (!validationin.eof())
{
validationin.getline(s, 500);
txt2++;
const char *d = " ";
char *p;
p = strtok(s, d);
double pe[6];
int num2 = 0;
for (int i = 0; i<6; i++)
{
pe[i] = em[i].ne*1.0 / txt1;
num2 += em[i].ve;
}
while (p) //这个while循环用来分词
{
string ss = p;
int comma = ss.find(",", 0);
if (comma < string::npos)
{
label[txt2] = ss.substr(comma + 1, ss.length() - comma - 1);
p[comma] = '\0';
}
for (emod = 0; emod<6; emod++)
{ //按照公式统计每个单词在各个标签下的先验概率
int pos = search(p);
if (pos<0) pos = 0;
pe[emod] *= ((nwe[emod][pos] + 1)*1.0 / (em[emod].nw + num2));
}
p = strtok(NULL, d);
}
string lb;
double maxx = 0;
for (int i = 0; i<6; i++)
{
if (pe[i]>maxx)
{
maxx = pe[i];
lb = em[i].es;
}
}
if (lb == label[txt2]) cnt++;
}
txt2--;
cout << cnt*1.0 / txt2 << endl;
cnt = 0;
testin.getline(s, 500);
while (!testin.eof())
{
testin.getline(s, 500);
const char *d = " ,";
char *p;
p = strtok(s, d);
double pe[6];
int num2 = 0;
for (int i = 0; i<6; i++)
{
pe[i] = em[i].ne*1.0 / txt1;
num2 += em[i].ve;
}
while (p)
{
if (isdigit(p[0]) || p[0] == '?')
{
p = strtok(NULL, d);
continue;
}
string ss = p;
int comma = ss.find(",", 0);
if (comma < string::npos)
{
label[txt2] = ss.substr(comma + 1, ss.length() - comma - 1);
p[comma] = '\0';
}
for (emod = 0; emod<6; emod++)
{
int pos = search(p);
if (pos<0) pos = 0;
pe[emod] *= ((nwe[emod][pos] + 1)*1.0 / (em[emod].nw + num2));
}
p = strtok(NULL, d);
}
string lb;
double maxx = 0;
for (int i = 0; i<6; i++)
{
if (pe[i]>maxx)
{
maxx = pe[i];
lb = em[i].es;
}
}
res << lb << endl;
}
return 0;
}
| [
"harryhan.1996@163.com"
] | harryhan.1996@163.com |
5d9007c3a4e5af623479805e08f8ff09fc33e4f5 | 4c1f553dea0955a07e24b8dacc205844bdefa154 | /src/connector.cpp | 707a823af6ad702dddf669b24e7b26f54722fa56 | [
"BSD-3-Clause"
] | permissive | binlabnet/keepassxc-client-library | b6544914c82e6b684c3d7abd3527f16e0ebb752d | a75c089eaa3bb8f1d674a14aabaeecb8fbe48d61 | refs/heads/master | 2021-10-09T04:11:51.418198 | 2018-12-21T00:11:38 | 2018-12-21T00:11:38 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 8,410 | cpp | #include "connector_p.h"
#include <QtCore/QDebug>
#include <QtCore/QJsonDocument>
#include <QtCore/QStandardPaths>
#include <chrono>
using namespace KPXCClient;
const QVersionNumber Connector::minimumKeePassXCVersion{2, 3, 0};
Connector::Connector(QObject *parent) :
QObject{parent},
_cryptor{new SodiumCryptor{this}},
_disconnectTimer{new QTimer{this}}
{
using namespace std::chrono_literals;
_disconnectTimer->setInterval(500ms);
_disconnectTimer->setSingleShot(true);
_disconnectTimer->setTimerType(Qt::CoarseTimer);
connect(_disconnectTimer, &QTimer::timeout,
this, &Connector::disconnectFromKeePass);
}
bool Connector::isConnected() const
{
return _connectPhase == PhaseConnected;
}
bool Connector::isConnecting() const
{
return _connectPhase == PhaseConnecting;
}
SodiumCryptor *Connector::cryptor() const
{
return _cryptor;
}
void Connector::connectToKeePass(const QString &target)
{
if(_process) {
emit error(Client::Error::ClientAlreadyConnected);
return;
}
if(!_cryptor->createKeys()){
emit error(Client::Error::ClientKeyGenerationFailed);
return;
}
_serverKey.deallocate();
_clientId = _cryptor->generateRandomNonce(SecureByteArray::State::Readonly);
_process = new QProcess{this};
_process->setProgram(target);
connect(_process, &QProcess::started,
this, &Connector::started);
connect(_process, QOverload<int, QProcess::ExitStatus>::of(&QProcess::finished),
this, &Connector::finished);
connect(_process, &QProcess::errorOccurred,
this, &Connector::procError);
connect(_process, &QProcess::readyReadStandardOutput,
this, &Connector::stdOutReady);
connect(_process, &QProcess::readyReadStandardError,
this, &Connector::stdErrReady);
_connectPhase = PhaseConnecting;
_process->start();
}
void Connector::disconnectFromKeePass()
{
if(!_process)
return;
switch(_connectPhase) {
case PhaseConnected:
qDebug() << "Disconnect Phase: Sending EOF";
_connectPhase = PhaseEof;
_process->closeWriteChannel();
_disconnectTimer->start();
break;
case PhaseConnecting:
case PhaseEof:
qDebug() << "Disconnect Phase: Sending SIGTERM";
_connectPhase = PhaseTerminate;
_process->terminate();
_disconnectTimer->start();
break;
case PhaseTerminate:
qDebug() << "Disconnect Phase: Sending SIGKILL";
_connectPhase = PhaseKill;
_process->kill();
_disconnectTimer->start();
break;
case PhaseKill:
qDebug() << "Disconnect Phase: Dropping process";
cleanup();
break;
default:
Q_UNREACHABLE();
break;
}
}
void Connector::sendEncrypted(const QString &action, QJsonObject message, bool triggerUnlock)
{
auto nonce = _cryptor->generateRandomNonce();
message[QStringLiteral("action")] = action;
#ifdef KPXCCLIENT_MSG_DEBUG
qDebug() << "[[SEND PLAIN MESSAGE]]" << message;
#endif
auto encData = _cryptor->encrypt(QJsonDocument{message}.toJson(QJsonDocument::Compact),
_serverKey,
nonce);
QJsonObject msgData;
msgData[QStringLiteral("action")] = action;
msgData[QStringLiteral("message")] = QString::fromUtf8(encData.toBase64());
msgData[QStringLiteral("nonce")] = nonce.toBase64();
msgData[QStringLiteral("clientID")] = _clientId.toBase64();
msgData[QStringLiteral("triggerUnlock")] = QVariant{triggerUnlock}.toString();
nonce.increment();
nonce.makeReadonly();
_allowedNonces.insert(nonce);
sendMessage(msgData);
}
void Connector::started()
{
_connectPhase = PhaseConnected;
auto nonce = _cryptor->generateRandomNonce();
QJsonObject keysMessage;
keysMessage[QStringLiteral("action")] = QStringLiteral("change-public-keys");
keysMessage[QStringLiteral("publicKey")] = _cryptor->publicKey().toBase64();
keysMessage[QStringLiteral("nonce")] = nonce.toBase64();
keysMessage[QStringLiteral("clientID")] = _clientId.toBase64();
nonce.increment();
nonce.makeReadonly();
_allowedNonces.insert(nonce);
sendMessage(keysMessage);
}
void Connector::finished(int exitCode, QProcess::ExitStatus exitStatus)
{
qInfo() << "Connection closed with code:" << exitCode
<< "(Status:" << exitStatus << ")";
cleanup();
emit disconnected();
}
void Connector::procError(QProcess::ProcessError error)
{
qCritical() << error << _process->errorString();
}
void Connector::stdOutReady()
{
// read the message
const auto encMessage = readMessageData();
#ifdef KPXCCLIENT_MSG_DEBUG
qDebug() << "[[RECEIVE RAW MESSAGE]]" << encMessage;
#endif
if(encMessage.isEmpty())
return;
// verify message
const auto action = encMessage[QStringLiteral("action")].toString();
if(!performChecks(action, encMessage))
return;
// handle special messages
if(action == QStringLiteral("change-public-keys")) {
handleChangePublicKeys(encMessage[QStringLiteral("publicKey")].toString());
return;
} else if(action == QStringLiteral("database-locked")) {
emit locked();
return;
} else if(action == QStringLiteral("database-unlocked")) {
emit unlocked();
return;
}
//verify nonce
const auto kpNonce = SecureByteArray::fromBase64(encMessage[QStringLiteral("nonce")].toString(), SecureByteArray::State::Readonly);
if(!_allowedNonces.remove(kpNonce)) {
emit messageFailed(action, Client::Error::ClientReceivedNonceInvalid);
return;
}
// decrypt message
const auto plainData = _cryptor->decrypt(QByteArray::fromBase64(encMessage[QStringLiteral("message")].toString().toUtf8()),
_serverKey,
kpNonce);
QJsonParseError error;
const auto message = QJsonDocument::fromJson(plainData, &error).object();
if(error.error != QJsonParseError::NoError){
emit messageFailed(action, Client::Error::ClientJsonParseError, error.errorString());
return;
}
#ifdef KPXCCLIENT_MSG_DEBUG
qDebug() << "[[RECEIVE PLAIN MESSAGE]]" << message;
#endif
// check for success
if(!performChecks(action, message))
return;
emit messageReceived(action, message);
}
void Connector::stdErrReady()
{
qWarning() << "stderr" << _process->readAllStandardError();
}
void Connector::sendMessage(const QJsonObject &message)
{
#ifdef KPXCCLIENT_MSG_DEBUG
qDebug() << "[[SEND RAW MESSAGE]]" << message;
#endif
const auto data = QJsonDocument{message}.toJson(QJsonDocument::Compact);
QByteArray length{sizeof(quint32), 0};
*reinterpret_cast<quint32*>(length.data()) = data.size();
_process->write(length + data);
}
void Connector::cleanup()
{
_disconnectTimer->stop();
if(_process) {
_process->disconnect(this);
_process->deleteLater();
_process = nullptr;
}
_cryptor->dropKeys();
_serverKey.deallocate();
_clientId.deallocate();
_allowedNonces.clear();
_connectPhase = PhaseKill;
}
QJsonObject Connector::readMessageData()
{
// read the data
const auto sizeData = _process->peek(sizeof(quint32));
if(sizeData.size() != sizeof(quint32))
return {};
const auto size = *reinterpret_cast<const quint32*>(sizeData.constData());
if(_process->bytesAvailable() < static_cast<qint64>(size + sizeof(quint32)))
return {};
_process->skip(sizeof(quint32));
const auto data = _process->read(size);
Q_ASSERT(data.size() == static_cast<int>(size));
// parse json
QJsonParseError error;
const auto message = QJsonDocument::fromJson(data, &error).object();
if(error.error != QJsonParseError::NoError) {
emit this->error(Client::Error::ClientJsonParseError, error.errorString());
return {};
} else
return message;
}
bool Connector::performChecks(const QString &action, const QJsonObject &message)
{
// verify version
if(message.contains(QStringLiteral("version"))) {
const auto kpVersion = QVersionNumber::fromString(message[QStringLiteral("version")].toString());
if(kpVersion < minimumKeePassXCVersion) {
messageFailed(action, Client::Error::ClientUnsupportedVersion, kpVersion.toString());
return false;
}
}
// read success status and cancel early if error
auto success = false;
if(message.contains(QStringLiteral("success")))
success = message[QStringLiteral("success")].toVariant().toBool();
else {
success = !message.contains(QStringLiteral("errorCode")) &&
!message.contains(QStringLiteral("error"));
}
if(!success) {
emit messageFailed(action,
static_cast<Client::Error>(message[QStringLiteral("errorCode")].toVariant().toInt()),
message[QStringLiteral("error")].toString());
return false;
}
return true;
}
void Connector::handleChangePublicKeys(const QString &publicKey)
{
_serverKey = SecureByteArray::fromBase64(publicKey, SecureByteArray::State::Readonly);
emit connected();
}
| [
"Skycoder42@users.noreply.github.com"
] | Skycoder42@users.noreply.github.com |
ef004e7492535ef2710ca0702e1c96f475542335 | 31a739950e0369187e4a5fd06718f933361ad0ca | /6853[D3].cpp | 2fd8f2a335ff7874e5381829b779b2e75dfe2231 | [] | no_license | devLupin/SWEA | a1dd6251d689116ddaef1e506c236acc9ff99c79 | 98d34043d3730fa4bfe9ab270f71e7db8f070d15 | refs/heads/master | 2020-06-25T10:33:00.772815 | 2019-12-26T16:00:49 | 2019-12-26T16:00:49 | 199,284,129 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 595 | cpp | #include <iostream>
using namespace std;
int main(void)
{
ios::sync_with_stdio(0);
cin.tie(0); cout.tie(0);
int T; cin >> T;
for (int tc = 1; tc <= T; tc++) {
int r1 = 0, r2 = 0, r3 = 0;
int x1, y1, x2, y2, n;
cin >> x1 >> y1 >> x2 >> y2 >> n;
for (int i = 0; i < n; i++) {
int x, y; cin >> x >> y;
if (x < x1 || x2 < x || y < y1 || y2 < y) {
r3++;
}
else if (x == x1 || x == x2 || y == y1 || y == y2) {
r2++;
}
else {
r1++;
}
}
cout << '#' << tc << ' ' << r1 << ' ' << r2 << ' ' << r3 << '\n';
}
return 0;
} | [
"noreply@github.com"
] | devLupin.noreply@github.com |
0b0890809ab5c7db14e2272cdd39cecc2a166dcc | 1f8e16c6db16c67b38d398f5c9ed788e27b56f03 | /mainwindow.cpp | 92a5509c6378588dfc5587757bf60f2acdc54a5d | [] | no_license | JosanSun/QtCustomProgressbar | 7657fc172c929f50c036bf26c1798ccd88c89e28 | d868e2fec3ca088ac738e68493fff99af2c9bb55 | refs/heads/master | 2020-03-10T16:54:53.287271 | 2018-04-14T05:51:22 | 2018-04-14T05:51:22 | 129,486,019 | 2 | 0 | null | 2018-04-14T05:46:32 | 2018-04-14T05:46:32 | null | UTF-8 | C++ | false | false | 651 | cpp | #include "mainwindow.h"
#include "ui_mainwindow.h"
MainWindow::MainWindow(QWidget *parent) :
QMainWindow(parent),
ui(new Ui::MainWindow)
{
ui->setupUi(this);
m_timer = new QTimer(this);
m_persent = 0;
connect(m_timer, SIGNAL(timeout()), this, SLOT(updateProgressbar()));
m_timer->start(100);
ui->bar4->startAnimation();
}
MainWindow::~MainWindow()
{
delete ui;
}
void MainWindow::updateProgressbar()
{
if(m_persent >= 100){
m_persent = 0;
}
else{
m_persent += 5;
}
ui->bar1->setValue(m_persent);
ui->bar2->setPersent(m_persent);
ui->bar3->setPersent(m_persent);
}
| [
"longxuanren@gmail.com"
] | longxuanren@gmail.com |
ddebb5290bee6e910822453f45f344a4178604e5 | 02157e976eff452c78876de5785b868430131e4a | /separate_Chaining/main.cpp | 23a0ac79b266020e61570098b1302774e522c096 | [] | no_license | qazi112/Testing | aaa3c0fc249f0ed8d4f3113dc254ff5a13471ae1 | eb10ecc97007ceae57c81fec1c31d203a14975a1 | refs/heads/master | 2020-08-17T06:43:10.048133 | 2019-12-19T09:24:25 | 2019-12-19T09:24:25 | 215,626,890 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,343 | cpp | #include <iostream>
const int TableSize=11;
using namespace std;
class Node
{
private:
int data;
Node *next;
public:
Node()
{ data=0;
next=NULL;
}
Node(int d)
{ data=d;
next=NULL;
}
void setData(int d);
void setPointer(Node *n);
int getData();
Node* getPointer();
};
void Node:: setData(int d)
{ data=d;
}
void Node:: setPointer( Node *n)
{ next=n;
}
int Node::getData()
{ return data;
}
Node* Node:: getPointer()
{ return next;
}
/*
****************
Node Class Ended
****************
*/
class LinkedList
{
private:
Node *first;
public:
LinkedList()
{ first=NULL;
}
void setFirst(Node *first);
Node* getFirst();
void add(int d);
void addAtStart(int d);
void removeFromStart();
void removeFromEnd();
void display();
int getSize();
void addAt(int value,int index);
void removeValue(int d);
};
void LinkedList:: setFirst(Node *first)
{ this->first=first;
}
Node* LinkedList:: getFirst()
{ return first;
}
void LinkedList::add(int d)
{ Node *temp=new Node(d);
if(first == NULL)
{
first=temp;
}
else
{
Node *second=first;
while(second->getPointer()!=NULL)
{
second=second->getPointer();
}
second->setPointer(temp);
}
}
void LinkedList::addAtStart(int d)
{ Node *temp=new Node(d);
Node *second=first;
first=temp;
temp->setPointer(second);
}
void LinkedList::removeFromStart()
{
first=first->getPointer();
}
void LinkedList::removeFromEnd()
{ Node *temp=first;
if(first==NULL)
{
return;
}
else if(temp->getPointer()==NULL)
{
first=NULL;
}
else
{
while(temp->getPointer()->getPointer()!=NULL)
{
temp=temp->getPointer();
}
temp->setPointer(NULL);
}
}
void LinkedList::display()
{ Node *temp=first;
if(first==NULL)
{
cout<<"Empty List\n";
}
else
{ while(temp!=NULL)
{ cout<<temp->getData()<<" \t";
temp=temp->getPointer();
}
}
}
int LinkedList::getSize()
{
if(first==NULL)
{
cout<<"List Is Empty!\n";
return 0;
}
else{
int i=0; // counter
Node *temp=first;
for( i=0; temp!=NULL; i++)
{
temp=temp->getPointer();
}
return i;
} // Length of List
}
void LinkedList::removeValue(int d)
{ Node *temp2=first;
Node *temp=first;
if(temp==NULL)
{ cout<<"Empty List\n";
}
else if(temp->getData()==d)
{ removeFromStart();
}
else
{ temp2=temp;
temp=temp->getPointer();
while(temp->getPointer()!=NULL)
{
if(temp->getData()==d)
{ temp2->setPointer(temp->getPointer());
break;
}
else
{ temp2=temp;
temp=temp->getPointer();
}
}
}
}
/*
****************
LinkedList Class Ended
****************
*/
class Hashing{
private:
LinkedList hashTable[11];
public:
Hashing()
{
for(int i=0;i<11;i++)
{
hashTable[i].setFirst(NULL);
}
}
int hash(int key);
void insert(int key);
void delete_Key(int key);
void search(int key);
void display();
};
int Hashing::hash(int key)
{
return key%TableSize;
}
void Hashing::insert(int key)
{
int index=hash(key);
hashTable[index].addAtStart(key);
}
void Hashing::search(int key)
{
int index=hash(key);
Node* temp=hashTable[index].getFirst();
while(temp!=NULL)
{
if(temp->getData()==key)
{
cout<<"Found\n";
return;
}
}
cout<<"Not Found\n";
}
void Hashing::delete_Key(int key)
{
int index=hash(key);
hashTable[index].removeValue(key);
}
void Hashing::display()
{
for(int i=0;i<TableSize;i++)
{
if(hashTable[i].getFirst()!=NULL)
{
cout<<i <<" "<<"->>>";
hashTable[i].display();
cout<<endl;
}
else{
cout<<i <<" "<<endl;
}
}
}
int main()
{
Hashing a;
a.insert(20);
a.insert(34);
a.insert(23);
a.insert(55);
a.insert(66);
a.delete_Key(66);
a.display();
}
| [
"qarsalan13@gmail.com"
] | qarsalan13@gmail.com |
dabc064ace25bb76339d34fae54f117de22bceea | c584abf107c128c4645866aea0becc948f933815 | /Integration.cpp | 3eb8e3a2a7d6d1bdb47d273c1ab511303126ca27 | [] | no_license | Warmuz/Integration | 9ba15c0eb1d4f3f0582c426ac6314079f5f7c9a9 | 9b57858efa1de0f851e85a774286ed1a7a0c042b | refs/heads/main | 2023-06-09T15:54:31.062471 | 2021-06-29T11:14:23 | 2021-06-29T11:14:23 | 381,337,070 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 5,623 | cpp | #include <iostream>
#include <cmath>
using namespace std;
double f (double x){
return exp(sin(2*x+1));
//return pow(x,3)+2*pow(x,2)-3*x+1;
//return pow(x,2)-x+1;
}
double f2(double x){
return -4*exp(sin(2*x+1))*(sin(2*x+1)-(cos(2*x+1)*cos(2*x+1)));
//return 6*x+4;
// return 2;
}
double f4(double x){
return 16*exp(sin(2*x+1))*((sin(2*x+1)*(3*sin(2*x+1)+1))+(cos(2*x+1)*cos(2*x+1)*cos(2*x+1)*cos(2*x+1))-2*(3*sin(2*x+1)+2)*cos(2*x+1)*cos(2*x+1));
//return 0;
}
double composite_rectangle(double a, double b, int m){
double h;
double *x;
double value=0;
x = new double [m+1];
h=(b-a)/m;
for(int i=0;i<=m;i++){
x[i]=a+i*h;
value += f(x[i])*h;
}
delete []x;
cout<<"Composite rectangle formula: "<<value<<endl;
cout<<endl;
return value;
}
//Composite trapezoid formula
double composite_trapezoid(double a, double b, int m){
double h;
double integral;
double value;
double error;
double *x;
double *y; //the largest element
y = new double [m];
x = new double [m+1];
h=(b-a)/m;
for(int i=0;i<=m;i++){
x[i]=a+i*h;
y[i]=f2(x[i]); //finding the largest element necesary for error
if(y[0]<y[i]){
y[0]=y[i];
}
}
value=0;
for(int i=0;i<=m-1;i++){
value += (f(x[i])+f(x[i+1]))/2;
}
integral=h*value;
error=fabs((m*pow(h,3))/12)*y[0];
delete []y;
delete []x;
cout<<"Composite Trapezoid formula: "<<integral<<endl;
cout<<"Error of Composite trapezoid formula: "<<error<<endl;
cout<<endl;
return integral;
}
double composite_simpson(double a, double b, int m){
double h;
double *x;
double *y;
double amount=(2*m)+1;
double value=0;
double error;
x = new double [amount];
y = new double [amount];
h=((b-a)/(2*m));
for(int i=0;i<amount;i++){
x[i]=a+i*h;
y[i]=f4(x[i]); //finding the largest element necesary for error
if(y[0]<y[i]){
y[0]=y[i];
}
if (i == 0 || i == 2*m)
value += f(x[i]);
else if (i%2 == 1)
value += 4*f(x[i]);
else if (i%2 == 0)
value += 2*f(x[i]);
}
value *=h/3;
error=fabs((m*pow(h,5)/90)*y[0]);
delete []y;
delete []x;
cout<<"Composite Simpson formula: "<<value<<endl;
cout<<"Error of Composite trapezoid formula: "<<error<<endl;
cout<<endl;
return h;
}
double rectangle(double a, double b)
{
cout << "Rectangle formula: " << f(a)*(b-a) << endl;
cout<<endl;
return f(a)*(b-a);
}
double trapezoid(double a, double b)
{
double h;
double integral;
double error;
double point=(b-a)/2;
h=(b-a);
integral=(h/2)*(f(a)+f(b));
error=(pow(h,3)*f2(point))/-12;
if(error>0){
integral -= error;
cout<<"Error: "<<error<<" So we substract to "<<(h/2)*(f(a)+f(b))<<endl;
}
else{
integral += error;
cout<<"Error: "<<error<<" So we add to "<<(h/2)*(f(a)+f(b))<<endl;
}
cout<<"Trapezoid formula: "<<integral<<endl;
cout<<endl;
return integral;
}
double simpson(double a, double b)
{
double x0 = a;
double x1 = (a+b)/2;
double x2 = b;
double h = (x2-x0)/2;
double integral =1;
double error;
integral = (h/3)*(f(x0)+(4*f(x1))+f(x2));
error=(pow(h,5)*f4(x1))/-90;
cout<<"Simpson formula: "<<integral<<endl;
cout<<"Error of simpson formula: "<<error<<endl;
cout<<endl;
return integral;
}
double boole (double a, double b){
double x[5];
double h=(b-a)/4;
double integral;
for(int i=0;i<5;i++){
x[i]=a+i*h;
}
integral = ((2*h)/45)*(4*f(x[0])+32*f(x[1])+12*f(x[2])+32*f(x[3])+7*f(x[4]));
cout<<"Boole'a formula: "<<integral<<endl;
cout<<endl;
return integral;
}
double chebyshev(double a, double b, int n)
{
double *t;
t = new double[n];
double *x;
x=new double [n];
double value=0;
double integral=0;
if(n==2)
{
t[0]=-0.57735;
t[1]=0.577350;
}
if(n==3){
t[0]=-0.707107;
t[1]=0;
t[2]=0.707107;
}
if(n==4)
{
t[0]=-0.794654;
t[1]=-0.187592;
t[2]=0.187592;
t[3]=0.794654;
}
if(n==5){
t[0]=-0.832498;
t[1]=-0.374541;
t[2]=0;
t[3]=0.374541;
t[4]=0.832498;
}
if(n==6){
t[0]=-0.866247;
t[1]=-0.422519;
t[2]=-0.266635;
t[3]=0.266635;
t[4]=0.422519;
t[5]=0.866247;
}
if(n==7){
t[0]=-0.883862;
t[1]=-0.529657;
t[2]=-0.323912;
t[3]=0;
t[4]=0.323912;
t[5]=0.529657;
t[6]=0.883862;
}
for(int i=0;i<n;i++){
x[i]=((a+b)/2)+(((a-b)/2)*(t[i]));
value += f(x[i]);
}
integral = value *((b-a)/n);
delete []x;
delete []t;
cout<<"Chebyshev formula: "<<integral<<endl;
cout<<endl;
return integral;
}
int main() {
double a=1, b=4;
int n=3; //Amount of chebyshev nodes
int m=4; //small sub-intervals
//rectangle(a,b);
//trapezoid(a,b);
//simpson(a,b);
//chebyshev(a,b,n);
//boole(a,b);
composite_trapezoid(a, b, m);
//composite_simpson(a,b,m);
//composite_rectangle(a,b,m);
//cout<< chebyshev(a,(b-a)/2,n)+chebyshev((b-a)/2,b,n)<<endl;
}
| [
"noreply@github.com"
] | Warmuz.noreply@github.com |
3a22d87917a102f020dcf61cf4b4805eb0964f2e | 54fc62bf9325cd3d4355e37fa199f951c3d265b2 | /clCircle.cpp | 408d4a22610e64851934ea65a4eae880f90c0dc5 | [] | no_license | Georgmil/sem3dz1 | f27b5b5fe43d7eb06c5f6dffe65b55ba68773cf1 | 877b933ae11102ba2bb207ab5c721523ba8281de | refs/heads/main | 2023-09-05T02:35:34.432582 | 2021-10-22T10:19:57 | 2021-10-22T10:19:57 | 416,492,709 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 302 | cpp | #include "clCircle.h"
void clCircle::Show(){
circle(x,y,r);
}
clCircle::clCircle()
{
//cout <<"clCircle();\n";
}
clCircle::clCircle(int x0, int y0):x(x0),y(y0)
{
//cout <<x<<"clCircle(int x0, int y0);\n";
}
clCircle::~clCircle()
{
//cout <<x <<"~clCircle();\n";
}
| [
"noreply@github.com"
] | Georgmil.noreply@github.com |
61f94925c1d18b0ec3948aee63e3134bdcf1a384 | 79827850a798d8cb9484709585c28dd7c1c2a276 | /programs/adminrea.cpp | 7e514e9a8b977dacbe1488f0ad5112b79e5232f1 | [] | no_license | vaibhavpareek/CPPNotes | bd615f448f372ed8879144a3e5b3ceae5ccc9d56 | 57cdbc0ef82fed6db43d03ff7271fff58d957720 | refs/heads/master | 2020-12-28T16:40:42.947455 | 2020-04-22T05:16:02 | 2020-04-22T05:16:02 | 238,407,934 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,018 | cpp | #include<iostream>
#include<fstream>
#include<unistd.h>
#include<stdio.h>
#include<stdlib.h>
#include<conio.h>
#include<string.h>
using namespace std;
class admin_info
{
char name_admin[80],passwd[80];
public:
void add_new_admin();
void search_admin();
}
void admin_info::add_new_admin()
{
cout<<"\n\n\n\t\t=============================================IPL CRICKET TOURNAMENT CONTROLLER=====================================================";
cout<<"\n\t\t\t\t\tPROCEED TO ADD NEW ADMIN IN DATABASES";
fstream file;
file.open("admin.txt",ios::app);
cout<<"\n\t\t\t\t\t\t\t\tNAME OF NEW ADMIN=";
cin.getline(name_admin,80);
fflush(stdin);
cout<<"\n\t\t\t\tt\t\t\t\tPASSWORD OF NEW ADMIN=";
cin.getline(passwd,80);
l1=strlen(passwd);
file<<name_admin<<passwd;
file.close();
}
void admin_info::search_admin()
{ char name[80],search[80];
int j=0;
fstream file;
file.open("admin.txt",ios::in|ios::binary);
file.seekg(0,ios::beg);
cout<<"\n\n\t\t\t\t=============================NEW ADMIN IS SUCCESSFULLY ADDED IN DATABASES==================================";
cout<<"\n\n\n\t\t=============================================IPL CRICKET TOURNAMENT CONTROLLER=====================================================";
cout<<"\n\n\t\t\t\t\t\t\tNAME=";
cin.getline(name,80);
cout<<"\n\n\t\t\t\t\t\t\tPASSWORD=";
while(j<l1)
{
search[j]=getch();
cout<<"*";
j++;
}
while(file.eof()==0)
{
file>>passwd;
cout<<search<<endl;
cout<<passwd;
if(!strcmp(passwd,search))
{
cout<<"\n\t\t\t\t\t\t\tWAIT..........AUTHENTICATING DATABASES................................";
sleep(7);
cout<<"\n\t\t\t================================= YOU HAVE SUCCESSFULLY LOGGED IN ====================================\n";
cout<<"\n\t\t\t\t\t=====================PRESS ANY KEY TO CONTINUE========================\n";
break;
}
else
{
cout<<"\n\t\t\t\t\t\t==========================ACCESS DENIED=======================";
cout<<"\n\t\t\t\t\t\t=============PASSWD IS WRONG PLEASE TRY AGAIN=============";
break;
}
}
file.close();
ofstream fi("counter.txt");
ch++;
fi.put(ch);
}
int main()
{
ifstream f("counter.txt");
while(!f.eof()==0)
{
ch=f.get();
}
f.close();
admin_info e[ch];
e[ch].add_new_admin();
for(i=0;i<ch;i++)
{
e[i].search_admin();
}
if(!strcmp(passwd,search))
{
cout<<"\n\t\t\t\t\t\t\tWAIT..........AUTHENTICATING DATABASES................................";
sleep(7);
cout<<"\n\t\t\t================================= YOU HAVE SUCCESSFULLY LOGGED IN ====================================\n";
cout<<"\n\t\t\t\t\t=====================PRESS ANY KEY TO CONTINUE========================\n";
break;
}
else
{
cout<<"\n\t\t\t\t\t\t==========================ACCESS DENIED=======================";
cout<<"\n\t\t\t\t\t\t=============PASSWD IS WRONG PLEASE TRY AGAIN=============";
break;
}
}
| [
"vaibhavpareekvp7@gmail.com"
] | vaibhavpareekvp7@gmail.com |
16f3da0df5ec67b2d480adaab371e7f147846830 | d98b942c84433f89876bab706fc5a9f4907770b1 | /bnn-fpga/cpp/accel/Accel.cpp | 16747049806e4d35fc312570c87e0c393c4f1880 | [
"BSD-3-Clause"
] | permissive | udbhav-chugh/CS577_Group13_Project | e5c33b755fe157fc7ae79a203ae1f348c08a4646 | 52dc5fb80e8798664f45098abeb051f78b79455f | refs/heads/main | 2023-04-04T00:41:21.948823 | 2021-04-11T13:21:21 | 2021-04-11T13:21:21 | 349,730,385 | 0 | 0 | null | 2021-03-26T16:20:46 | 2021-03-20T13:19:02 | C | UTF-8 | C++ | false | false | 31,307 | cpp | #include <iostream>
#include <iomanip>
#include <hls_stream.h>
#include "Accel.h"
#include "AccelPrint.h"
const static Word m1("0x5555555555555555", 16);
const static Word m2("0x3333333333333333", 16);
const static Word m4("0x0f0f0f0f0f0f0f0f", 16);
const static Word h01("0x0101010101010101", 16);
// -----------------------------------------------------------------------
// Hardware-specific print helpers
// -----------------------------------------------------------------------
template<typename T>
void print_ap_bits(const T& in, const unsigned W) {
#pragma HLS INLINE
#pragma HLS PIPELINE II=1
printf (" ");
for (unsigned i = 0; i < W; ++i)
// #pragma HLS PIPELINE II=1
printf ("%3d", in[i] ? -1 : 0);
printf ("\n");
}
template<typename T>
void print_params(T params[CONVOLVERS][K][K]) {
#pragma HLS INLINE
#pragma HLS PIPELINE II=1
for (unsigned m = 0; m < CONVOLVERS; ++m) {
for (unsigned wr = 0; wr < K; ++wr) {
for (unsigned wc = 0; wc < K; ++wc) {
// #pragma HLS PIPELINE II=1
printf ("%3d", (params[m][wr][wc]==0) ? 0 : 1);
}
printf("\n");
}
printf("--\n");
}
}
template<typename T>
void print_line_buffer_m(T lbuf[CONV_BANKS]) {
#pragma HLS INLINE
#pragma HLS PIPELINE II=1
for (unsigned wr = 0; wr < CONV_ROWS; ++wr) {
for (unsigned bank = 0; bank < CONV_BANKS; ++bank) {
for (unsigned wc = 0; wc < CONV_COLS; ++wc) {
// #pragma HLS PIPELINE II=1
printf ("%3d", lbuf[bank][wr][wc].to_int());
}
printf (" |");
}
printf ("\n");
}
}
TwoBit encode_bit(const Bit& b) {
#pragma HLS INLINE
#pragma HLS PIPELINE II=1
return (b == 0) ? TwoBit(1) : TwoBit(-1);
}
// -----------------------------------------------------------------------
// Conv
// -----------------------------------------------------------------------
ConvOut conv3x3b(
const TwoBit line_buffer_m[CONV_BANKS][CONV_ROWS][CONV_COLS],
const Bit conv_params_m[K][K],
const ap_uint<4> bank,
const IdxType cc
) {
#pragma HLS INLINE
#pragma HLS PIPELINE II=1
ConvOut sum = 0;
for (ap_uint<2> kr = 0; kr < K; ++kr) {
for (ap_uint<2> kc = 0; kc < K; ++kc) {
// #pragma HLS PIPELINE II=1
TwoBit data = line_buffer_m[bank][kr][cc+kc];
const Bit& wt = conv_params_m[2-kr][2-kc];
data[1] = (wt & data[0]) ^ data[1];
sum += data;
}
}
return sum;
}
// -----------------------------------------------------------------------
// Produce 32 elements of conv results
// -----------------------------------------------------------------------
void conv_word(
const TwoBit line_buffer_m[CONV_BANKS][CONV_ROWS][CONV_COLS],
const Bit conv_params_m[K][K],
ConvOut conv_out_buffer_m[WORD_SIZE]
) {
#pragma HLS INLINE
#pragma HLS PIPELINE II=1
for (ap_uint<4> bank = 0; bank < CONV_BANKS; ++bank) {
for (ap_uint<4> cc = 0; cc < BANK_WIDTH; ++cc) {
// #pragma HLS PIPELINE II=1
conv_out_buffer_m[bank*BANK_WIDTH+cc] = conv3x3b( line_buffer_m, conv_params_m, bank, cc );
}
}
}
// -----------------------------------------------------------------------
// Process each line in a word, we need to outline this loop to
// avoid false control dependencies in Vivado HLS
// -----------------------------------------------------------------------
void process_word(
const TwoBit word_buffer_m[CONV_BANKS][CONV_COLS],
const TwoBit old_word_buffer_m[CONV_BANKS][CONV_COLS],
const bool lb[CONV_BANKS],
const bool rb[CONV_BANKS],
TwoBit line_buffer_m[CONV_BANKS][CONV_ROWS][CONV_COLS],
const Bit conv_params_m[K][K],
ConvOut conv_out_buffer_m[WORD_SIZE],
const ap_uint<3> log_width,
const ap_uint<6> words_per_image,
const IdxType wrd
) {
#pragma HLS INLINE
// #pragma HLS PIPELINE II=1
// slices_per_line = width / BANK_WIDTH
const ap_uint<5> slices_per_line = 1 << (log_width - LOG_BANK_WIDTH);
const bool first_wrd = (wrd == 0);
const bool last_wrd = (wrd == words_per_image);
DB_PRINT(4, "process word %d, spl=%d\n", wrd.to_int(), slices_per_line.to_int());
// Prologue
// Update bottom row, slices are shifted left. Some slices copied from previous word (middle row)
for (ap_uint<4> bank = 0; bank < CONV_BANKS; ++bank) {
ap_int<6> s_idx = bank + slices_per_line - CONV_BANKS;
if (s_idx < 0) {
// set to zero or copy from old word (middle row)
for (ap_uint<4> cc = 1; cc < CONV_COLS-1; ++cc) {
// #pragma HLS PIPELINE II=1
line_buffer_m[bank][CONV_ROWS-1][cc] = old_word_buffer_m[CONV_BANKS+s_idx][cc];
}
line_buffer_m[bank][CONV_ROWS-1][0 ] = lb[bank] ? TwoBit(0) : old_word_buffer_m[CONV_BANKS+s_idx][0];
line_buffer_m[bank][CONV_ROWS-1][CONV_COLS-1] = rb[bank] ? TwoBit(0) : old_word_buffer_m[CONV_BANKS+s_idx][CONV_COLS-1];
} else {
// fill from new word
for (ap_uint<4> cc = 1; cc < CONV_COLS-1; ++cc) {
// #pragma HLS PIPELINE II=1
line_buffer_m[bank][CONV_ROWS-1][cc] = (last_wrd) ? TwoBit(0) : word_buffer_m[s_idx][cc];
}
line_buffer_m[bank][CONV_ROWS-1][0 ] = (last_wrd || lb[bank]) ? TwoBit(0) : word_buffer_m[s_idx][0];
line_buffer_m[bank][CONV_ROWS-1][CONV_COLS-1] = (last_wrd || rb[bank]) ? TwoBit(0) : word_buffer_m[s_idx][CONV_COLS-1];
}
}
DB(4,
printf("Accel lbuf wrd%d before conv:\n", wrd.to_int());
print_line_buffer_m(line_buffer_m);
);
// Convolution
conv_word( line_buffer_m, conv_params_m, conv_out_buffer_m );
// Update
// Fill line buffer with lines from the new word
for (ap_uint<4> bank = 0; bank < CONV_BANKS; ++bank) {
// --------------------------------------------------------------
// Top row, slices are shifted right by slices_per_line
ap_int<6> s_idx0 = bank - slices_per_line;
if (s_idx0 >= 0) {
// slice from input word
for (ap_uint<4> cc = 1; cc < CONV_COLS-1; ++cc) {
// #pragma HLS PIPELINE II=1
line_buffer_m[bank][0][cc] = word_buffer_m[s_idx0][cc];
}
line_buffer_m[bank][0][0 ] = lb[bank] ? TwoBit(0) : word_buffer_m[s_idx0][0];
line_buffer_m[bank][0][CONV_COLS-1] = rb[bank] ? TwoBit(0) : word_buffer_m[s_idx0][CONV_COLS-1];
} else {
// set to zero or copy from old word (middle row)
for (ap_uint<4> cc = 1; cc < CONV_COLS-1; ++cc) {
// #pragma HLS PIPELINE II=1
line_buffer_m[bank][0][cc] = (first_wrd) ? TwoBit(0) : old_word_buffer_m[CONV_BANKS+s_idx0][cc];
}
line_buffer_m[bank][0][0 ] = (first_wrd || lb[bank]) ? TwoBit(0) : old_word_buffer_m[CONV_BANKS+s_idx0][0];
line_buffer_m[bank][0][CONV_COLS-1] = (first_wrd || rb[bank]) ? TwoBit(0) : old_word_buffer_m[CONV_BANKS+s_idx0][CONV_COLS-1];
}
// --------------------------------------------------------------
// Middle row, simply copy the word into the line buffer
for (ap_uint<4> cc = 1; cc < CONV_COLS-1; ++cc) {
// #pragma HLS PIPELINE II=1
line_buffer_m[bank][1][cc] = word_buffer_m[bank][cc];
}
// Fill end buffer bits
line_buffer_m[bank][1][0 ] = lb[bank] ? TwoBit(0) : word_buffer_m[bank][0];
line_buffer_m[bank][1][CONV_COLS-1] = rb[bank] ? TwoBit(0) : word_buffer_m[bank][CONV_COLS-1];
}
DB(4,
printf("Accel lbuf wrd%d after conv:\n", wrd.to_int());
print_line_buffer_m(line_buffer_m);
);
}
// -----------------------------------------------------------------------
// A single PE reads from all inputs and weights to generate a single
// output feature map.
// * Make sure this function gets inlined by VHLS, or cosim may fail!
// -----------------------------------------------------------------------
void bin_conv(
Word wt_mem[CONVOLVERS][C_WT_WORDS],
NormComp nc,
Word dmem[2][CONVOLVERS][C_DMEM_WORDS],
ap_uint<1> d_i_idx,
ap_uint<1> d_o_idx,
const unsigned n_inputs,
const Address o_index,
const ap_uint<1> new_batch,
const ap_uint<2> width_mode, // 0=8'b, 1=16'b, 2=32'b
const ap_uint<2> norm_mode // 0='do nothing', 1='do norm', 2='do pool'
) {
// #pragma HLS allocation instances=LUT limit=2
// #pragma HLS allocation instances=mul limit=1 operation
// #pragma HLS PIPELINE II=1
const ap_uint<3> log_width = width_mode + LOG_BANK_WIDTH;
const ap_uint<5> words_per_image = 1 << (2*width_mode);
const unsigned n_phases = n_inputs / CONVOLVERS;
const unsigned images_per_phase = PIX_PER_PHASE >> (2*log_width);
const unsigned WORDS_PER_PHASE = PIX_PER_PHASE / WORD_SIZE;
assert(n_phases % images_per_phase == 0);
assert(n_inputs % images_per_phase == 0);
assert(images_per_phase*words_per_image == WORDS_PER_PHASE);
// ---------------------------------------------------------------------
// buffers
// ---------------------------------------------------------------------
TwoBit line_buffer[CONVOLVERS][CONV_BANKS][CONV_ROWS][CONV_COLS];
Bit conv_params[CONVOLVERS][K][K];
ConvSum fixed_buffer[WORDS_PER_PHASE][WORD_SIZE];
ConvSum fixed_temp[WORD_SIZE];
// per-convolver buffers
TwoBit word_buffer[CONVOLVERS][CONV_BANKS][CONV_COLS];
TwoBit old_word_buffer[CONVOLVERS][CONV_BANKS][CONV_COLS];
ConvOut conv_out_buffer[CONVOLVERS][WORD_SIZE];
// edge padding flag bits
bool lb[CONV_BANKS];
bool rb[CONV_BANKS];
#pragma HLS ARRAY_PARTITION variable=line_buffer cyclic factor=2 dim=0
#pragma HLS ARRAY_PARTITION variable=conv_params complete
#pragma HLS ARRAY_PARTITION variable=fixed_buffer cyclic factor=4 dim=2
#pragma HLS ARRAY_PARTITION variable=fixed_temp cyclic factor=4 dim=1
#pragma HLS ARRAY_PARTITION variable=word_buffer cyclic factor=2 dim=0
#pragma HLS ARRAY_PARTITION variable=old_word_buffer cyclic factor=2 dim=0
#pragma HLS ARRAY_PARTITION variable=conv_out_buffer cyclic factor=4 dim=2
// #pragma HLS ARRAY_RESHAPE variable=dmem cyclic factor=4 dim=3
static Address wt_addr = 0; // address of weight word
static ap_uint<3> wt_offset = 0; // offset 0..6 of param
if (new_batch != 0) { wt_addr = 0; wt_offset = 0; }
// ---------------------------------------------------------------------
// Calculate edge padding flag bits
const ap_uint<4> log_slice = log_width - LOG_BANK_WIDTH;
const ap_uint<4> w_div_8 = (1 << log_width) >> 3;
assert (w_div_8 > 0);
ap_uint<4> mask = ~ap_uint<4>(0); // set mask to all 1s
mask = mask >> (4-log_slice);
for (ap_uint<4> bank = 0; bank < 64/8; ++bank) {
#pragma HLS unroll
const ap_uint<4> x = bank & mask;
lb[bank] = (x == 0); // (bank % w_div_8) == 0
rb[bank] = (x+1 == w_div_8); // (bank % w_div_8) == w_div_8-1
}
// ---------------------------------------------------------------------
// Reset conv buffer
for (IdxType i = 0; i < 32; ++i) {
for (IdxType j = 0; j < 64; ++j) {
#pragma HLS UNROLL
fixed_buffer[i][j] = 0;
}
}
// ---------------------------------------------------------------------
// Compute in phases
// Each phase processes CONVOLVERS * WORDS_PER_PHASE input words
// ---------------------------------------------------------------------
LOOP_PHASES:
for (ap_uint<10> p = 0; p < 64/2; p += 32) {
DB(3, printf ("=== PHASE %d ===\n", p.to_int()) );
// wrd = which word in the current image
// wrd_phase = which wrd in the current phase
ap_uint<8> wrd = 0;
ap_uint<8> wrd_phase = 0;
// Load a word each iteration, and then process it
// We load WORDS_PER_PHASE words per phase, however we also need 1 extra "empty"
// iteration per image in the phase to do the loop epilogue, so the loop bound
// is WORDS_PER_PHASE + images_per_phase
LOOP_WORDS_IN_PHASE:
for (ap_uint<8> count = 0; count < 32+32; ++count) {
#pragma HLS PIPELINE II=1
// First word of an image
if (wrd == 0) {
Word wt_word_buffer[CONVOLVERS];
// -------------------------------------------------------------------
// Load param word
// Each word contains CONV_W_PER_WORD weight filters, after we use
// them all we should load the next word
// -------------------------------------------------------------------
LOOP_WT_WORDS:
for (IdxType m = 0; m < 2; ++m) {
// #pragma HLS PIPELINE II=1
/*if (wt_offset == 0)
wt_word_buffer[m] = wt_mem[m][wt_addr];
else
wt_word_buffer[m] = wt_word_buffer[m] >> WT_SIZE;
*/
wt_word_buffer[m] = wt_mem[m][wt_addr] >> ap_uint<6>(WT_SIZE*wt_offset);
}
if (wt_offset == CONV_W_PER_WORD-1) {
++wt_addr;
wt_offset = 0;
} else {
++wt_offset;
}
//print_wt_word(wt_word_buffer[0]);
// -------------------------------------------------------------------
// Load params
// Each word contains CONV_W_PER_WORD weight filters packed into the first
// 63 bits, the last bit is unused. Wts are stored in output-major order.
// -------------------------------------------------------------------
LOOP_LOAD_WTS:
for (IdxType m = 0; m < 2; ++m) {
for (ap_uint<2> kr = 0; kr < 3; ++kr) {
for (ap_uint<2> kc = 0; kc < 3; ++kc){
// #pragma HLS PIPELINE II=1
conv_params[m][kr][kc] = wt_word_buffer[m][kr*K+kc];
}
}
}
DB(3, print_params(conv_params) );
}
// -------------------------------------------------------------------
// Every word in an image
// -------------------------------------------------------------------
// Load word
// (wrd_phase-wrd) is which wrd in the current phase, aligned to img boundary
if (wrd != words_per_image) {
LOOP_CONVOLVER_LOAD:
for (IdxType m = 0; m < 2; ++m) {
Word word = dmem[d_i_idx][m][p*words_per_image + wrd_phase];
for (IdxType bank = 0; bank < 8; ++bank) {
for (IdxType cc = 0; cc < 10-2; ++cc) {
// #pragma HLS PIPELINE II=1
word_buffer[m][bank][cc+1] = encode_bit(word[ap_uint<6>(bank*BANK_WIDTH+cc)]);
}
word_buffer[m][bank][0 ] = (bank==0) ?
TwoBit(0) : encode_bit(word[ap_uint<6>(bank*BANK_WIDTH-1)]);
word_buffer[m][bank][CONV_COLS-1] = (bank==CONV_BANKS-1) ?
TwoBit(0) : encode_bit(word[ap_uint<6>(bank*BANK_WIDTH+BANK_WIDTH)]);
}
}
}
// Compute
LOOP_CONVOLVERS:
for (IdxType m = 0; m < 2; ++m) {
// #pragma HLS PIPELINE II=1
// Do the following for each word in an image
process_word( word_buffer[m], old_word_buffer[m], lb, rb, line_buffer[m], conv_params[m],
conv_out_buffer[m], log_width, words_per_image, wrd );
} // CONVOLVERS
for (IdxType m = 0; m < 2; ++m) {
for (IdxType bank = 0; bank < 8; ++bank) {
for (IdxType cc = 0; cc < 10; ++cc) {
// #pragma HLS PIPELINE II=1
old_word_buffer[m][bank][cc] = word_buffer[m][bank][cc];
} }
}
// -------------------------------------------------------------------
// Sum results across convolvers
// -------------------------------------------------------------------
for (IdxType i = 0; i < 64; ++i) {
// Ignore conv results after processing the first word
if (wrd > 0) {
ConvSum s = 0;
for (IdxType m = 0; m < 2; ++m){
// #pragma HLS PIPELINE II=1
s += conv_out_buffer[m][i];
}
fixed_buffer[wrd_phase-1][i] += s;
}
}
// -------------------------------------------------------------------
// Increment counters
// -------------------------------------------------------------------
if (wrd != words_per_image) {
wrd++;
wrd_phase++;
} else {
wrd = 0;
}
} // wrd_phase = 0 .. WORDS_PER_PHASE
} // n_phases
LOOP_ACC_PHASES:
for (ap_uint<5> w = 0; w < 1; ++w) {
for (IdxType b = 0; b < 64; ++b) {
// #pragma HLS PIPELINE II=1
#pragma HLS unroll
fixed_temp[b] = fixed_buffer[w][b];
}
LOOP_ACC_PHASES_I:
for (ap_uint<8> i = 1; i < 32; i += 1) {
for (IdxType b = 0; b < 64; ++b) {
#pragma HLS unroll
fixed_temp[b] += fixed_buffer[w+i][b];
} }
for (IdxType b = 0; b < 64; ++b) {
// #pragma HLS PIPELINE II=1
#pragma HLS unroll
fixed_buffer[w][b] = fixed_temp[b];
}
}
const Address bank_idx = o_index % CONVOLVERS;
const Address bank_off = o_index / CONVOLVERS;
const ap_uint<5> pool_width = 1 << (log_width-1);
DB(4,
unsigned width = 1 << log_width;
printf ("=== conv result ===\n");
print_mat(fixed_buffer[0], width, 8, width);
);
DB_PRINT(2, " o_idx=%3d: nc=%6d\n", o_index.to_int(), nc.to_int());
static Word outword;
Word poolword;
LOOP_BATCH_NORM:
for (ap_uint<6> w = 0; w < 1; ++w) {
#pragma HLS PIPELINE II=1
Word binword;
Address o_bank_idx = bank_idx;
Address o_bank_offset = bank_off*words_per_image + w;
const ap_uint<6> out_offset = (w % 4) << 4;
for (ap_uint<7> i = 0; i < 64; ++i) {
#pragma HLS unroll
binword[i] = (fixed_buffer[w][i] >= nc) ? 0 : 1;
}
if (norm_mode == 1) {
outword = binword;
}
else if (norm_mode == 2) {
// horizontal pooling first
ap_int<WORD_SIZE/2> poolword_h;
for (ap_uint<6> i = 0; i < 64/2; ++i) {
#pragma HLS unroll
poolword_h[i] = binword[2*i] & binword[2*i+1];
}
// vertical pooling
for (ap_uint<6> i = 0; i < 64/4; ++i) {
#pragma HLS unroll
// source indices
ap_uint<5> i0 = i >> (log_width-1);
i0 = (i0 << log_width) + i(log_width-2,0);
ap_uint<5> i1 = i0 + pool_width;
// dest index
ap_uint<6> d0 = out_offset + i;
poolword[d0] = poolword_h[i0] & poolword_h[i1];
}
// For log_width > 3 we can just assign the word, but log_width = 3 means width = 8,
// which means pooled width = 4, which is only 16 bits, which is less than 1 Word.
// So each time we get here we only have 16 bits, meaning we have to accumulate four
// of these 16-bit batches before writing a word out.
if (log_width != LOG_BANK_WIDTH) {
o_bank_offset /= 4;
outword = poolword;
} else {
outword = outword >> WORD_SIZE/4;
outword(63,48) = poolword(15,0);
o_bank_idx = (o_index/4)%CONVOLVERS;
o_bank_offset = (o_index/4)/CONVOLVERS;
}
}
dmem[d_o_idx][o_bank_idx][o_bank_offset] = outword;
}
}
// -----------------------------------------------------------------------
// Module to do the first conv layer
// -----------------------------------------------------------------------
void fp_conv(
Word wt_mem[CONVOLVERS][C_WT_WORDS],
Word kh_mem[KH_WORDS],
Word dmem[2][CONVOLVERS][C_DMEM_WORDS],
ap_uint<1> d_i_idx,
ap_uint<1> d_o_idx,
const Address kh_index,
const Address o_index,
const unsigned N
) {
const unsigned M = 3;
const unsigned S = 32;
const unsigned OUTWORDS = 16; // words per output image
C1InputType win[M][K][K];
C1InputType lbuf[M][K-1][S];
Word outwords[OUTWORDS];
WtType wtbuf[M];
Address wt_offset = 0;
ap_uint<3> wt_addr = 0;
// Parallelized across m, better for HLS
LOOP_FP_CONV_O:
for (IdxType n = 0; n < N; ++n) {
// clear linebuffers for each new output map
LOOP_RESET_LINEBUFFERS:
for (IdxType m = 0; m < M; ++m) {
PROLOG_COLS: for (IdxType c = 0; c < S; ++c) {
PROLOG_ROWS: for (IdxType r = 0; r < K/2; ++r) {
for (IdxType lr = 0; lr < K-2; ++lr) {
lbuf[m][lr][c] = lbuf[m][lr+1][c];
}
lbuf[m][K-2][c] = 0;
} }
}
// The weights for the 1st conv layer are just laid out
// linearly across wt_mem, 3 weights per 64-bit word
DB_PRINT(3, "n = %u\n", n.to_int());
Word wt_word = wt_mem[n % CONVOLVERS][n / CONVOLVERS];
LOOP_LOAD_WTS:
for (ap_uint<2> m = 0; m < M; ++m) {
wtbuf[m] = wt_word((m+1)*WT_SIZE-1, m*WT_SIZE);
DB(3, print_wt(wtbuf[m]));
DB(3, printf("--\n"));
}
// load batch norm params
C1Comp nc;
load_kh(nc, kh_mem, (kh_index+n));
//printf (" n=%3d, nc=%6.3f\n", n.to_int(), nc.to_float());
// begin convolution
LOOP_CONV_ROWS: for (IdxType r = 0; r < S+1; ++r) {
LOOP_CONV_COLS: for (IdxType c = 0; c < S+1; ++c) {
// load input word
Word inword = 0;
if (r < S && c < S) {
const Address addr = r*S + c;
inword = dmem[d_i_idx][addr/C_DMEM_WORDS][addr%C_DMEM_WORDS];
}
for (ap_uint<2> m = 0; m < M; ++m) {
// load data: the value of pix is either the pixel at [r,c]
// 0 -> +1, -1 -> -1
// or -> 0 for padding around the boundaries
C1InputType pix;
const unsigned W = pix.length();
pix(W-1,0) = inword(W-1+m*W, m*W);
// window: shift left, leaving rightmost col for new data
for (IdxType wr = 0; wr < K; ++wr) {
for (IdxType wc = 0; wc < K-1; ++wc) {
win[m][wr][wc] = win[m][wr][wc+1];
} }
// window: fill top K-1 pixels of rightmost column from lbuf
for (IdxType wr = 0; wr < K-1; ++wr) {
C1InputType val = (c != S) ? lbuf[m][wr][c] : C1InputType(0);
win[m][wr][K-1] = val;
}
// window: fill bottom right with new input pixel
win[m][K-1][K-1] = pix;
// lbuf: shift up column c
if (c != S) {
for (IdxType lr = 0; lr < K-2; ++lr) {
lbuf[m][lr][c] = lbuf[m][lr+1][c];
}
lbuf[m][K-2][c] = pix;
}
} // m
// only perform the conv and store if legal position
if (r > 0 && c > 0) {
C1ConvType res = 0;
for (ap_uint<2> m = 0; m < M; ++m) {
for (ap_uint<2> wr = 0; wr < K; ++wr) {
for (ap_uint<2> wc = 0; wc < K; ++wc) {
const C1InputType& pix = win[m][wr][wc];
const Bit& b = wtbuf[m][8-(wr*K+wc)];
res += (b==0) ? pix : (C1InputType)(-pix);
} }
}
// perform normalization right here
outwords[(r-1)/2][((r-1)%2)*S + (c-1)] =
(res >= nc) ? Bit(0) : Bit(-1);
}
} // CONV_COLS
} // CONV_ROWS
// Here i is the word offset within the outwords buffer
LOOP_OUTPUT:
for (IdxType i = 0; i < OUTWORDS; ++i) {
Address img_idx = o_index+n;
Address bank_idx = img_idx % CONVOLVERS;
Address bank_off = img_idx / CONVOLVERS;
dmem[d_o_idx][bank_idx][bank_off*OUTWORDS + i] = outwords[i];
}
} // n
}
void bin_dense(
const Word wt_mem[CONVOLVERS][C_WT_WORDS],
const Word kh_mem[KH_WORDS],
Word dmem[2][CONVOLVERS][C_DMEM_WORDS],
ap_uint<2> layer_type,
ap_uint<1> d_i_idx,
ap_uint<1> d_o_idx,
const Address o_index,
const unsigned n_inputs,
const unsigned n_outputs
) {
//assert(n_outputs % WORD_SIZE == 0);
assert(layer_type == LAYER_DENSE || n_outputs == 10);
assert(n_inputs/WORD_SIZE % CONVOLVERS == 0);
DenseSum sum_m[CONVOLVERS];
// for last layer
DenseNorm best_out = -1024;
ap_int<8> prediction = -1;
// read words from dmem and the wt store, dot them
// o is the output bit, i is the input bit
LOOP_DENSE_O:
for (Address o = 0; o < 1; ++o) {
const Address o_addr = (o_index+o)/WORD_SIZE;
const ap_uint<6> o_offset = (o_index+o) % WORD_SIZE;
Word o_word = dmem[d_o_idx][o_addr%CONVOLVERS][o_addr/CONVOLVERS];
DenseSum sum = 0;
LOOP_DENSE_I:
for (Address i = 0; i < 64; i+=CONVOLVERS*WORD_SIZE) {
const Address wt_addr = (o*n_inputs+i) / WORD_SIZE;
for (IdxType j = 0; j < 2; ++j) {
#pragma HLS unroll
// in_wrd addr = [(i/WORD_SIZE+j) % CONVOLVERS][(i/WORD_SIZE+j) / CONVOLVERS]
// wt_wrd addr = [wt_addr % CONVOLVERS][wt_addr / CONVOLVERS]
const Word in_wrd = dmem[d_i_idx][j][i/WORD_SIZE/CONVOLVERS];
const Word wt_wrd = wt_mem[j][wt_addr / CONVOLVERS];
Word x = wt_wrd ^ in_wrd;
// count_set bit for 64 bits, returns 2*cnt
x -= (x >> 1) & m1;
x = (x & m2) + ((x >> 2) & m2);
x = (x + (x >> 4)) & m4;
x += x >> 8;
x += x >> 16;
x += x >> 32;
x = x & 0x7f;
sum_m[j] = WORD_SIZE - (DenseSum)(x<<1);
}
for (IdxType j = 0; j < 2; ++j)
#pragma HLS unroll
sum += sum_m[j];
} // n_inputs
// not last layer -> biniarize,
// otherwise just store the value as a 64bit word
if (layer_type == LAYER_DENSE) {
Address kh_addr = o / KH_PER_WORD;
Word kh_word = kh_mem[kh_addr];
NormComp nc;
IdxType kh_off = o % KH_PER_WORD;
if (kh_off == 0)
nc(15,0) = kh_word(15, 0);
else if (kh_off == 1)
nc(15,0) = kh_word(31,16);
else if (kh_off == 2)
nc(15,0) = kh_word(47,32);
else
nc(15,0) = kh_word(63,48);
o_word[o_offset] = (sum >= nc) ? 0 : 1;
} else {
Address kh_addr = o / (const unsigned)2;
Word kh_word = kh_mem[kh_addr];
KType ki; HType hi;
IdxType kh_off = o % 2;
if (kh_off == 0) {
ki(15,0) = kh_word(15, 0);
hi(15,0) = kh_word(31,16);
} else {
ki(15,0) = kh_word(47,32);
hi(15,0) = kh_word(63,48);
}
//printf (" >> %d * %f + %f\n", sum.to_int(), ki.to_float(), hi.to_float());
ap_fixed<20,10> out = ap_fixed<20,10>(sum)*ki + hi;
if (o == 0 || out > best_out) {
prediction = o;
best_out = out;
}
}
dmem[d_o_idx][o_addr%CONVOLVERS][o_addr/CONVOLVERS] = o_word;
} // n_outputs
// Here we are using o_index as a bit index, not a word index!
if (layer_type == LAYER_LAST) {
Word o_word;
o_word(7,0) = prediction(7,0);
o_word(WORD_SIZE-1, 8) = 0;
dmem[d_o_idx][0][0] = o_word;
}
}
// -----------------------------------------------------------------------
// Accelerator top module
// -----------------------------------------------------------------------
void top(
Word wt_i[WT_WORDS],
Word kh_i[KH_WORDS],
Word dmem_i[DMEM_WORDS],
Word dmem_o[DMEM_O_WORDS],
const Address n_inputs,
const Address n_outputs,
const Address input_words,
const Address output_words,
const ap_uint<3> layer_mode, // [0]='new layer', [2:1]='conv1,conv,dense,last'
const ap_uint<1> dmem_mode, // 0 means dmem[0] is input
const ap_uint<2> width_mode, // 0=8'b, 1=16'b, 2=32'b
const ap_uint<2> norm_mode // 0='do nothing', 1='do norm', 2='do pool'
) {
DB_PRINT(2, "==== Entering Accel ====\n");
const ap_uint<2> layer_type = layer_mode(2,1);
const unsigned width = 8 << width_mode;
DB_PRINT(1, " Inputs = %d\n", n_inputs.to_int());
DB_PRINT(1, " Outputs = %d\n", n_outputs.to_int());
DB_PRINT(1, " i_words = %d\n", input_words.to_int());
DB_PRINT(1, " o_words = %d\n", output_words.to_int());
DB_PRINT(1, " Width = %d\n", width);
DB_PRINT(1, " layer_mode = %d %d\n", layer_mode[0]==0 ? 0 : 1, layer_type.to_int());
DB_PRINT(1, " dmem_mode = %d\n", dmem_mode.to_int());
assert(width <= MAX_WIDTH);
assert(n_inputs != 0);
if (layer_type <= LAYER_CONV) {
assert(input_words % CONVOLVERS == 0);
assert(n_inputs*width*width <= DMEM_WORDS*WORD_SIZE);
assert(n_inputs*WT_SIZE <= WT_WORDS*WORD_SIZE);
}
static Word dmem[2][CONVOLVERS][C_DMEM_WORDS];
static Word kh_mem[KH_WORDS];
static Word wt_mem[CONVOLVERS][C_WT_WORDS];
static Address kh_index = 0;
static Address o_index = 0;
if (layer_mode[0]) {
kh_index = 0;
o_index = 0;
} else {
kh_index = kh_index[0];
}
ap_uint<1> d_i_idx = dmem_mode;
ap_uint<1> d_o_idx = ~dmem_mode;
// Data input
const ap_uint<5> words_per_image = 1 << (2*width_mode);
Address img_idx = 0; // i / words_per_image;
IdxType img_off = 0; // i % words_per_image;
LOOP_DMEM_I: for (Address i = 0; i < 64; ++i) {
#pragma HLS PIPELINE II=1
if (layer_type == LAYER_CONV) {
Address bank_idx = img_idx % CONVOLVERS;
Address bank_off = img_idx / CONVOLVERS;
dmem[d_i_idx][bank_idx][(bank_off<<(2*width_mode)) + img_off] = dmem_i[i];
}
else if (layer_type == LAYER_CONV1)
dmem[d_i_idx][i/C_DMEM_WORDS][i%C_DMEM_WORDS] = dmem_i[i];
else
dmem[d_i_idx][i%CONVOLVERS][i/CONVOLVERS] = dmem_i[i];
if (++img_off == words_per_image) {
img_off = 0;
++img_idx;
}
}
// Weight input, we must copy every 64-bit Word from the interface
// into the accelerator
LOOP_WT_I: for (Address i = 0; i < C_WT_WORDS*CONVOLVERS; ++i) {
#pragma HLS PIPELINE II=1
wt_mem[i%CONVOLVERS][i/CONVOLVERS] = wt_i[i];
}
//printf ("\nAccel Weights:\n");
//print_params3d(wt_mem[0], 0, n_inputs*n_outputs);
LOOP_KH_I: for (ap_uint<16> i = 0; i < KH_WORDS; ++i){
#pragma HLS PIPELINE II=1
kh_mem[i] = kh_i[i];
}
// if (layer_type == LAYER_CONV1) {
// assert(n_inputs == 3);
// // fp_conv(
// // wt_mem,
// // kh_mem,
// // dmem,
// // d_i_idx,
// // d_o_idx,
// // kh_index,
// // o_index,
// // n_outputs
// // );
// kh_index += n_outputs;
// o_index += n_outputs;
// }
// else if (layer_type == LAYER_CONV) {
assert(norm_mode != 2 || n_outputs % 4 == 0); // needed for pooling of 8x8 image
assert(n_inputs % CONVOLVERS == 0);
LOOP_IMG_BATCH:
for (IdxType i = 0; i < 1; ++i) {
// Load the batch-norm parameters for this output
// #pragma HLS PIPELINE II=1
NormComp nc;
load_kh(nc, kh_mem, kh_index);
bin_conv(
wt_mem,
nc,
dmem,
d_i_idx, d_o_idx,
n_inputs,
o_index,
i == 0 ? 1 : 0, // new_batch
width_mode,
norm_mode
);
kh_index++;
o_index++;
}
// }
// else {
// bin_dense(
// wt_mem,
// kh_mem,
// dmem,
// layer_type,
// d_i_idx, d_o_idx,
// o_index,
// n_inputs, n_outputs
// );
// o_index += n_outputs;
// } // layer_type
// Data output
ap_uint<5> words_per_out = words_per_image / ((norm_mode!=2) ? 1 : 4);
img_idx = 0;
img_off = 0;
LOOP_DMEM_O: for (Address i = 0; i < 1; ++i) {
#pragma HLS PIPELINE II=1
// exclude conv6 (width==8, norm_mode==2) here because it writes
// the output fmaps linearly
if (layer_type <= LAYER_CONV && !(width_mode == 0 && norm_mode == 2)) {
Address bank_idx = img_idx % CONVOLVERS;
Address bank_off = img_idx / CONVOLVERS;
dmem_o[i] = dmem[d_o_idx][bank_idx][bank_off*words_per_out + img_off];
}
else
dmem_o[i] = dmem[d_o_idx][i%CONVOLVERS][i/CONVOLVERS];
if (++img_off == words_per_out) {
img_off = 0;
++img_idx;
}
}
}
| [
"baranwalm2002@gmail.com"
] | baranwalm2002@gmail.com |
fbd70151b1e34a5974d7a569748eef1ce8970a7c | 948f4e13af6b3014582909cc6d762606f2a43365 | /testcases/juliet_test_suite/testcases/CWE127_Buffer_Underread/s03/CWE127_Buffer_Underread__new_wchar_t_cpy_52a.cpp | 4eba59ae2650621a6e165c97292efc4db118ab57 | [] | no_license | junxzm1990/ASAN-- | 0056a341b8537142e10373c8417f27d7825ad89b | ca96e46422407a55bed4aa551a6ad28ec1eeef4e | refs/heads/master | 2022-08-02T15:38:56.286555 | 2022-06-16T22:19:54 | 2022-06-16T22:19:54 | 408,238,453 | 74 | 13 | null | 2022-06-16T22:19:55 | 2021-09-19T21:14:59 | null | UTF-8 | C++ | false | false | 2,525 | cpp | /* TEMPLATE GENERATED TESTCASE FILE
Filename: CWE127_Buffer_Underread__new_wchar_t_cpy_52a.cpp
Label Definition File: CWE127_Buffer_Underread__new.label.xml
Template File: sources-sink-52a.tmpl.cpp
*/
/*
* @description
* CWE: 127 Buffer Under-read
* BadSource: Set data pointer to before the allocated memory buffer
* GoodSource: Set data pointer to the allocated memory buffer
* Sink: cpy
* BadSink : Copy data to string using wcscpy
* Flow Variant: 52 Data flow: data passed as an argument from one function to another to another in three different source files
*
* */
#include "std_testcase.h"
#include <wchar.h>
namespace CWE127_Buffer_Underread__new_wchar_t_cpy_52
{
#ifndef OMITBAD
/* bad function declaration */
void badSink_b(wchar_t * data);
void bad()
{
wchar_t * data;
data = NULL;
{
wchar_t * dataBuffer = new wchar_t[100];
wmemset(dataBuffer, L'A', 100-1);
dataBuffer[100-1] = L'\0';
/* FLAW: Set data pointer to before the allocated memory buffer */
data = dataBuffer - 8;
}
badSink_b(data);
}
#endif /* OMITBAD */
#ifndef OMITGOOD
/* good function declarations */
void goodG2BSink_b(wchar_t * data);
/* goodG2B uses the GoodSource with the BadSink */
static void goodG2B()
{
wchar_t * data;
data = NULL;
{
wchar_t * dataBuffer = new wchar_t[100];
wmemset(dataBuffer, L'A', 100-1);
dataBuffer[100-1] = L'\0';
/* FIX: Set data pointer to the allocated memory buffer */
data = dataBuffer;
}
goodG2BSink_b(data);
}
void good()
{
goodG2B();
}
#endif /* OMITGOOD */
} /* close namespace */
/* Below is the main(). It is only used when building this testcase on
its own for testing or for building a binary to use in testing binary
analysis tools. It is not used when compiling all the testcases as one
application, which is how source code analysis tools are tested. */
#ifdef INCLUDEMAIN
using namespace CWE127_Buffer_Underread__new_wchar_t_cpy_52; /* so that we can use good and bad easily */
int main(int argc, char * argv[])
{
/* seed randomness */
srand( (unsigned)time(NULL) );
#ifndef OMITGOOD
printLine("Calling good()...");
good();
printLine("Finished good()");
#endif /* OMITGOOD */
#ifndef OMITBAD
printLine("Calling bad()...");
bad();
printLine("Finished bad()");
#endif /* OMITBAD */
return 0;
}
#endif
| [
"yzhang0701@gmail.com"
] | yzhang0701@gmail.com |
3ee805eef1fc495900671d7dcc8988b4a37e3b39 | cad04bb71f3afd50c4df3b2f321cd378d3ad8cb9 | /OJ practices/LeetCode题目集/191. Number of 1 Bits(easy)-蛮力算法.cpp | 03c96848fe11120371026192c063f9a710881bfb | [] | no_license | SourDumplings/CodeSolutions | 9033de38005b1d90488e64ccbb99f91c7e7b71ec | 5f9eca3fe5701a8fca234343fde31cfcba94cf27 | refs/heads/master | 2023-08-16T17:23:34.977471 | 2023-08-07T13:14:47 | 2023-08-07T13:14:47 | 110,331,879 | 10 | 8 | null | 2023-06-14T22:25:16 | 2017-11-11T08:59:11 | C | UTF-8 | C++ | false | false | 516 | cpp | /*
* @Author: SourDumplings
* @Date: 2019-07-31 18:03:39
* @Link: https://github.com/SourDumplings/
* @Email: changzheng300@foxmail.com
* @Description: https://leetcode.com/problems/number-of-1-bits/
*/
class Solution
{
public:
int hammingWeight(uint32_t n)
{
int res = 0;
uint32_t mask = 1;
int num = 32;
while (num--)
{
if (n & mask)
{
++res;
}
mask <<= 1;
}
return res;
}
}; | [
"changzheng@harmonycloud.com.cn"
] | changzheng@harmonycloud.com.cn |
e7531229db6a9cea69070a69a5e89e21d6602ce7 | cb567676c21f77fe48390ad6254a30bdeee535b0 | /Reverse Bits (Bit Manipulation).cpp | 1f03428215a7f90c59d03e5974b872c6be54d50a | [] | no_license | mandeep-1/DSA_PracticeWork | 800c89409d660389fd473f06d14a92fb32d944d9 | 1ce8fb3cbf243591e0483a23ab11786ae5b24f6a | refs/heads/main | 2023-01-13T01:49:51.959561 | 2020-11-18T14:54:52 | 2020-11-18T14:54:52 | 313,960,677 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 613 | cpp | #include <bits/stdc++.h>
using namespace std;
// Function to invert bits of a number
uint32_t invertBits(uint32_t n)
{
// Calculate number of bits of N-1;
uint32_t x = log2(n) ;
cout<<"Number of bits = "<<x<<endl;
uint32_t m = 1 << x;
cout<<"m = 1<<x is "<<m<<endl;
m = m | m - 1;
cout<<"m = m | m - 1 is "<<m<<endl;
n = n ^ m;
cout<<"n = n ^ m is "<<n<<endl;
return n;
}
// Driver code
int main()
{
int tc;
cin>>tc;
while(tc--)
{
uint32_t num;
cin>>num;
uint32_t x = invertBits(num);
cout << "Reverse is "<<x<<endl;
}
return 0;
}
| [
"mandeepk.pantal@gmail.com"
] | mandeepk.pantal@gmail.com |
c5a0f1260b8cfdd14a2cae96e6b8d4ad5ff126d0 | 4c1891b1cb97f1f7e2b0e0640dcdf9c0303c2069 | /cs106library/StanfordCPPLib/goptionpane.cpp | a28e66216dca15f9e9c3448489f69b5bbe3561c1 | [] | no_license | phoenixjun/cplusplus | 8d6eb56206f1ebc32d803e42bdaf951c6db2b122 | abea50d6ac0275b57e06f6c730e5192713fc58d3 | refs/heads/master | 2021-01-10T06:17:29.486347 | 2016-01-12T11:47:58 | 2016-01-12T11:47:58 | 49,495,958 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,013 | cpp | /*
* File: goptionpane.cpp
* ---------------------
* This file implements the operations declared in the goptionpane.h file.
* See goptionpane.h for documentation of each member.
*
* @author Marty Stepp
* @version 2015/07/05
* - removed static global Platform variable, replaced by getPlatform as needed
* @version 2014/10/26
* - added showTextFileDialog
* @version 2014/10/09
* - finished implementation of showOptionDialog; added dialog types and other fixes
* - enum rearrangement for clearer client code and better error messages
* - removed 'using namespace' statement
* @since 2014/07/09
*/
#include "goptionpane.h"
#include "platform.h"
GOptionPane::GOptionPane() {
// empty
}
GOptionPane::ConfirmResult GOptionPane::showConfirmDialog(std::string message, std::string title,
ConfirmType type) {
if (type != YES_NO
&& type != YES_NO_CANCEL
&& type != OK_CANCEL) {
error("GOptionPane::showConfirmDialog: Illegal dialog type");
}
if (title.empty()) {
title = "Select an option";
}
int result = getPlatform()->goptionpane_showConfirmDialog(message, title, type);
if (result == OK_OPTION || result == YES_OPTION) {
// this is weird code because JOptionPane thinks of OK and Yes as the same,
// and differentiates based on context of whether this is an OK/Cancel or Yes/No dialog
return (type == OK_CANCEL)
? OK : YES;
} else if (result == NO_OPTION) {
return NO;
} else {
return CANCEL;
}
}
std::string GOptionPane::showInputDialog(std::string message, std::string title) {
return getPlatform()->goptionpane_showInputDialog(message, title);
}
void GOptionPane::showMessageDialog(std::string message, std::string title, MessageType type) {
if (type != PLAIN
&& type != INFORMATION
&& type != ERROR
&& type != WARNING
&& type != QUESTION) {
error("GOptionPane::showMessageDialog: Illegal dialog type");
}
if (title.empty()) {
title = "Message";
}
getPlatform()->goptionpane_showMessageDialog(message, title, type);
}
std::string GOptionPane::showOptionDialog(std::string message, const Vector<std::string>& options,
std::string title, std::string initiallySelected) {
if (title.empty()) {
title = "Select an option";
}
int index = getPlatform()->goptionpane_showOptionDialog(message, title, options.toStlVector(), initiallySelected);
if (index == CLOSED_OPTION
|| index < 0 || index >= options.size()) {
return "";
} else {
return options[index];
}
}
void GOptionPane::showTextFileDialog(std::string message, std::string title, int rows, int cols) {
if (title.empty()) {
title = "Text file contents";
}
getPlatform()->goptionpane_showTextFileDialog(message, title, rows, cols);
}
| [
"unknown-user@192.168.0.8"
] | unknown-user@192.168.0.8 |
07cffa5f98e05ad0d3ff19bc3f8d891bbc25ec4b | af8f6f52241c3bd5fb4953732fc4e350de6d6eae | /Huffman Coding.cpp | d71032b94937a55852d96700c31e8487ffe2fde5 | [] | no_license | priyanshu29470/Problem-Solving---Algorithms-Collection | 094ae87e366df478b28927e967048ca267a1d58f | eef9bb00db549fc2eb6a904b5a74bd2005b2cf77 | refs/heads/main | 2023-01-03T13:18:02.402904 | 2020-10-31T15:11:34 | 2020-10-31T15:11:34 | 308,909,266 | 0 | 0 | null | 2020-10-31T15:14:39 | 2020-10-31T15:14:38 | null | UTF-8 | C++ | false | false | 2,338 | cpp | // C++ program for Huffman Coding
#include <bits/stdc++.h>
using namespace std;
// A Huffman tree node
struct MinHeapNode {
// One of the input characters
char data;
// Frequency of the character
unsigned freq;
// Left and right child
MinHeapNode *left, *right;
MinHeapNode(char data, unsigned freq)
{
left = right = NULL;
this->data = data;
this->freq = freq;
}
};
// For comparison of
// two heap nodes (needed in min heap)
struct compare {
bool operator()(MinHeapNode* l, MinHeapNode* r)
{
return (l->freq > r->freq);
}
};
// Prints huffman codes from
// the root of Huffman Tree.
void printCodes(struct MinHeapNode* root, string str)
{
if (!root)
return;
if (root->data != '$')
cout << root->data << ": " << str << "\n";
printCodes(root->left, str + "0");
printCodes(root->right, str + "1");
}
// The main function that builds a Huffman Tree and
// print codes by traversing the built Huffman Tree
void HuffmanCodes(char data[], int freq[], int size)
{
struct MinHeapNode *left, *right, *top;
// Create a min heap & inserts all characters of data[]
priority_queue<MinHeapNode*, vector<MinHeapNode*>, compare> minHeap;
for (int i = 0; i < size; ++i)
minHeap.push(new MinHeapNode(data[i], freq[i]));
// Iterate while size of heap doesn't become 1
while (minHeap.size() != 1) {
// Extract the two minimum
// freq items from min heap
left = minHeap.top();
minHeap.pop();
right = minHeap.top();
minHeap.pop();
// Create a new internal node with
// frequency equal to the sum of the
// two nodes frequencies. Make the
// two extracted node as left and right children
// of this new node. Add this node
// to the min heap '$' is a special value
// for internal nodes, not used
top = new MinHeapNode('$', left->freq + right->freq);
top->left = left;
top->right = right;
minHeap.push(top);
}
// Print Huffman codes using
// the Huffman tree built above
printCodes(minHeap.top(), "");
}
// Driver program to test above functions
int main()
{
char arr[] = { 'a', 'b', 'c', 'd', 'e', 'f' };
int freq[] = { 5, 9, 12, 13, 16, 45 };
int size = sizeof(arr) / sizeof(arr[0]);
HuffmanCodes(arr, freq, size);
return 0;
}
// This code is contributed by Aditya Goel
| [
"noreply@github.com"
] | priyanshu29470.noreply@github.com |
3651ec4805125222b1430278f72119afb2c0b5b8 | 9870e11c26c15aec3cc13bc910e711367749a7ff | /HD/hd_4292.cpp | 1a43183956e5080d8b223e9a53f5a0bf7b5ef21f | [] | no_license | liuq901/code | 56eddb81972d00f2b733121505555b7c7cbc2544 | fcbfba70338d3d10bad2a4c08f59d501761c205a | refs/heads/master | 2021-01-15T23:50:10.570996 | 2016-01-16T16:14:18 | 2016-01-16T16:14:18 | 12,918,517 | 1 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 2,074 | cpp | #include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
const int inf=2100000000;
int tot,S,T,b[810],a[1000000][3];
void add(int x,int y,int z)
{
a[++tot][0]=y,a[tot][1]=z,a[tot][2]=b[x],b[x]=tot;
a[++tot][0]=x,a[tot][1]=0,a[tot][2]=b[y],b[y]=tot;
}
int d[810],q[810];
bool build()
{
memset(d,0,sizeof(d));
int l,r;
q[l=r=1]=S;
d[S]=1;
while (l<=r)
{
int x=q[l++];
for (int i=b[x];i;i=a[i][2])
{
int y=a[i][0];
if (d[y] || !a[i][1])
continue;
d[y]=d[x]+1;
q[++r]=y;
if (y==T)
return(true);
}
}
return(false);
}
int dinic(int x,int flow)
{
if (x==T)
return(flow);
int k=flow;
for (int i=b[x];i;i=a[i][2])
{
int y=a[i][0];
if (d[y]!=d[x]+1 || !a[i][1])
continue;
int t=dinic(y,min(k,a[i][1]));
k-=t;
a[i][1]-=t;
a[i^1][1]+=t;
if (!k)
break;
}
if (k==flow)
d[x]=-1;
return(flow-k);
}
char s[1000];
int main()
{
int n,F,D;;
while (scanf("%d%d%d",&n,&F,&D)==3)
{
S=F+D+2*n+1;
T=F+D+2*n+2;
memset(b,0,sizeof(b));
tot=1;
for (int i=1;i<=n;i++)
add(i+F+D,i+F+D+n,1);
for (int i=1;i<=F;i++)
{
int x;
scanf("%d",&x);
add(S,i,x);
}
for (int i=1;i<=D;i++)
{
int x;
scanf("%d",&x);
add(i+F,T,x);
}
for (int i=1;i<=n;i++)
{
scanf("%s",s+1);
for (int j=1;j<=F;j++)
if (s[j]=='Y')
add(j,i+F+D,1);
}
for (int i=1;i<=n;i++)
{
scanf("%s",s+1);
for (int j=1;j<=D;j++)
if (s[j]=='Y')
add(i+F+D+n,j+F,1);
}
int ans=0;
while (build())
ans+=dinic(S,inf);
printf("%d\n",ans);
}
return(0);
}
| [
"liuq901@163.com"
] | liuq901@163.com |
4d96102700715dad3b946362d51e325444b471da | d52fdcfb556d7e9ea9fa89bf2f4442d1072e89f0 | /Renderer/NullRenderer/include/NullRenderer/TextureBuffer.h | 4f384fb62fdd0e5aef2e223240d3662122800bf2 | [
"MIT"
] | permissive | thewolfwillcome/unrimp | a292c3898f7ff530e9aa555d361d948730f939fa | 3d6269c749016a35c72473654cc6e3533b3ab348 | refs/heads/master | 2020-11-30T15:07:14.733681 | 2013-01-27T08:40:11 | 2013-01-27T08:40:11 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,587 | h | /*********************************************************\
* Copyright (c) 2012-2013 Christian Ofenberg
*
* 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.
\*********************************************************/
//[-------------------------------------------------------]
//[ Header guard ]
//[-------------------------------------------------------]
#pragma once
#ifndef __NULLRENDERER_TEXTUREBUFFER_H__
#define __NULLRENDERER_TEXTUREBUFFER_H__
//[-------------------------------------------------------]
//[ Includes ]
//[-------------------------------------------------------]
#include <Renderer/ITextureBuffer.h>
//[-------------------------------------------------------]
//[ Namespace ]
//[-------------------------------------------------------]
namespace NullRenderer
{
//[-------------------------------------------------------]
//[ Forward declarations ]
//[-------------------------------------------------------]
class NullRenderer;
//[-------------------------------------------------------]
//[ Classes ]
//[-------------------------------------------------------]
/**
* @brief
* Null texture buffer object (TBO) class
*/
class TextureBuffer : public Renderer::ITextureBuffer
{
//[-------------------------------------------------------]
//[ Public methods ]
//[-------------------------------------------------------]
public:
/**
* @brief
* Constructor
*
* @param[in] nullRenderer
* Owner null renderer instance
*/
explicit TextureBuffer(NullRenderer &nullRenderer);
/**
* @brief
* Destructor
*/
virtual ~TextureBuffer();
//[-------------------------------------------------------]
//[ Public virtual Renderer::ITextureBuffer methods ]
//[-------------------------------------------------------]
public:
virtual void copyDataFrom(unsigned int numberOfBytes, const void *data) override;
};
//[-------------------------------------------------------]
//[ Namespace ]
//[-------------------------------------------------------]
} // NullRenderer
//[-------------------------------------------------------]
//[ Header guard ]
//[-------------------------------------------------------]
#endif // __NULLRENDERER_TEXTUREBUFFER_H__
| [
"c.ofenberg@pixellight.org"
] | c.ofenberg@pixellight.org |
49cfb47fb41199f43d9ab34e343cc1b39c737e37 | 22b87f3243e58fbb6ed4661909d8544c7c255a56 | /utils.cpp | 16d4d037c99f285136fbd47151398efb8cda7f68 | [
"Apache-2.0"
] | permissive | TheHolyJoker/Pocket-Dictionaries-Benchmarks | 57297e7ecb02404f0f0ab406732688c8fa322235 | f651d1082c277e539964e831a526e9404c623a44 | refs/heads/master | 2022-12-18T14:57:43.928812 | 2020-09-20T16:29:52 | 2020-09-20T16:29:52 | 294,442,063 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 460 | cpp | #include "utils.hpp"
void set_pd(__m512i *pd, size_t quot_range, size_t capacity) {
__m512i temp_pd = __m512i{(INT64_C(1) << 50) - 1, 0, 0, 0, 0, 0, 0, 0};
for (size_t i = 0; i < capacity; i++) {
uint64_t quot = rand() % quot_range;
uint8_t rem = rand() & 255;
bool res = pd512::pd_add_50(quot, rem, &temp_pd);
assert(res);
assert(pd512::pd_find_50(quot, rem, &temp_pd));
}
memcpy(pd, &temp_pd, 64);
}
| [
"tomereven@mail.tau.ac.il"
] | tomereven@mail.tau.ac.il |
76ffc0725a9a4e645399ddb5e7c8f003a261c026 | e31e2511a3e79a702bc21b216affba52e669e11c | /eva/ckks/scales_checker.h | e567aa4ee27082b563189e78462c55b115093850 | [
"MIT"
] | permissive | weibeld/EVA | 8427d11d705476f2f322340bbb1f5bd61bb94dc2 | 7ea9d34b0380c25c03fe529fe9a755a6477144ce | refs/heads/main | 2023-07-09T18:15:35.572664 | 2021-05-01T09:12:24 | 2021-05-01T10:00:46 | 397,862,296 | 0 | 1 | MIT | 2021-08-19T07:54:19 | 2021-08-19T07:54:18 | null | UTF-8 | C++ | false | false | 2,812 | h | // Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT license.
#pragma once
#include "eva/ir/program.h"
#include "eva/ir/term_map.h"
#include <cassert>
#include <cstddef>
#include <cstdint>
namespace eva {
class ScalesChecker {
public:
ScalesChecker(Program &g, TermMapOptional<std::uint32_t> &scales,
TermMap<Type> &types)
: program_(g), scales_(g), types_(types) {}
void operator()(const Term::Ptr &term) {
// Must only be used with forward pass traversal
if (types_[term] == Type::Raw) {
return;
}
auto &operands = term->getOperands();
// Nothing to do for source terms
if (term->op == Op::Input || term->op == Op::Encode) {
scales_[term] = term->get<EncodeAtScaleAttribute>();
if (scales_.at(term) == 0) {
if (term->op == Op::Input) {
throw std::runtime_error("Program has an input with 0 scale");
} else {
throw std::logic_error("Compiled program results in a 0 scale term");
}
}
} else if (term->op == Op::Mul) {
assert(term->numOperands() == 2);
std::uint32_t scale = 0;
for (auto &operand : operands) {
scale += scales_.at(operand);
}
if (scale == 0) {
throw std::logic_error("Compiled program results in a 0 scale term");
}
scales_[term] = scale;
} else if (term->op == Op::Rescale) {
assert(term->numOperands() == 1);
auto divisor = term->get<RescaleDivisorAttribute>();
auto operandScale = scales_.at(term->operandAt(0));
std::uint32_t scale = operandScale - divisor;
if (scale == 0) {
throw std::logic_error("Compiled program results in a 0 scale term");
}
scales_[term] = scale;
} else if (isAdditionOp(term->op)) {
std::uint32_t scale = 0;
for (auto &operand : operands) {
if (scale == 0) {
scale = scales_.at(operand);
} else {
if (scale != scales_.at(operand)) {
throw std::logic_error("Addition or subtraction in program has "
"operands of non-equal scale");
}
}
}
if (scale == 0) {
throw std::logic_error("Compiled program results in a 0 scale term");
}
scales_[term] = scale;
} else {
auto scale = scales_.at(term->operandAt(0));
if (scale == 0) {
throw std::logic_error("Compiled program results in a 0 scale term");
}
scales_[term] = scale;
}
}
void free(const Term::Ptr &term) {
// No-op
}
private:
Program &program_;
TermMapOptional<std::uint32_t> scales_;
TermMap<Type> &types_;
bool isAdditionOp(const Op &op_code) {
return ((op_code == Op::Add) || (op_code == Op::Sub));
}
};
} // namespace eva
| [
"olsaarik@microsoft.com"
] | olsaarik@microsoft.com |
0afcf6c737dc72cd7ebb89273b7fc86acac4f373 | 84f40bb83ae4a76e96330da1d4cc48a29c2bf5ce | /sorting/evil.cpp | bca072a0af1c1871c166a17431bbf16ecfa082a4 | [] | no_license | nikifaets/Algo | 7136db930448cc8daa0e64b9c24721587cfed2d0 | 55842cc584e09ef3c3f1e293c1f7555e56b59496 | refs/heads/main | 2023-06-08T16:57:18.334918 | 2021-06-26T22:08:42 | 2021-06-26T22:08:42 | 357,473,449 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,097 | cpp | #include <bits/stdc++.h>
using namespace std;
int main(){
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, m;
cin >> n >> m;
priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> q;
for(int i=0; i<m; i++){
int l, r;
cin >> l >> r;
q.push({l, r});
}
if(q.empty()){
cout << 0 << endl;
return 0;
}
pair<int, int> last = q.top();
q.pop();
int leftmost = last.first;
int rightmost = last.second;
int covered = rightmost - leftmost + 1;
while(!q.empty()){
pair<int, int> next = q.top();
if(rightmost >= next.first && next.second > rightmost){
covered += next.second - rightmost;
rightmost = next.second;
}
else if(next.first > rightmost){
leftmost = next.first;
rightmost = next.second;
covered += rightmost - leftmost + 1;
}
last = move(next);
q.pop();
}
cout << covered << endl;
} | [
"nikifaets11@gmail.com"
] | nikifaets11@gmail.com |
f4304bc15d00b4bc0b88b6f6881a4def7b3e891a | bd686124a27fbcfef72d69e272702fdf89f7abea | /src/backend/CLHPrinter.hpp | fb5840b23fa58dc9924e72fae3867ca18a0d2e20 | [
"Apache-2.0"
] | permissive | jiajian-xiao/OpenABLext | 3ec4deeff3ba7793c4383ad010a7a0293905a40a | 015d3dd5159feb41c865b455fadf77f0f8dc51ed | refs/heads/master | 2022-11-14T16:04:16.396938 | 2020-02-25T10:43:51 | 2020-02-25T10:43:51 | 221,669,486 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 1,865 | hpp | /* Copyright 2017 OpenABL Contributors
*
* 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. */
#pragma once
#include "AST.hpp"
#include "GenericCPrinter.hpp"
namespace OpenABL {
struct CLHPrinter : public GenericCPrinter {
using GenericCPrinter::print;
CLHPrinter(AST::Script &script, bool useFloat, bool isConflictResolutionEnabled)
: GenericCPrinter(script), script(script), useFloat(useFloat), isConflictResolutionEnabled(isConflictResolutionEnabled) {}
void print(const AST::CallExpression &);
void print(const AST::MemberInitEntry &);
void print(const AST::AgentCreationExpression &);
void print(const AST::NewArrayExpression &);
void print(const AST::MemberAccessExpression &);
void print(const AST::AssignStatement &);
void print(const AST::VarDeclarationStatement &);
void print(const AST::ForStatement &);
void print(const AST::SimulateStatement &);
void print(const AST::FunctionDeclaration &);
void print(const AST::AgentMember &);
void print(const AST::AgentDeclaration &);
void print(const AST::Script &);
void print(const AST::EnvironmentDeclaration &);
void printType(Type t);
private:
AST::Script &script;
bool useFloat;
bool generateForGraph;
std::string envName;
std::string envType;
int envSizeValue;
Value envGraphSize;
bool isConflictResolutionEnabled;
bool useRNG;
};
}
| [
"jiajian.xiao@tum-create.edu.sg"
] | jiajian.xiao@tum-create.edu.sg |
47d72cf0566a8520cdfd7084b7bf863a99baeeb7 | a65f12e7039ddc3a915c1237b876df82ca17537e | /aws-cpp-sdk-lex-models/source/model/IntentMetadata.cpp | 98f60c9521809aa316202199d9e43285e91d5f6b | [
"Apache-2.0",
"MIT",
"JSON"
] | permissive | chiaming0914/awe-cpp-sdk | 1a09da8ce36f8a60b9bb47c47fc576c822ccf398 | 5cd54671ea48151f33f0ddbadc3d68ffacbc160b | refs/heads/master | 2021-06-16T18:25:10.864269 | 2017-06-08T07:02:09 | 2017-06-08T07:02:09 | 93,716,067 | 0 | 0 | null | 2017-06-08T08:06:39 | 2017-06-08T06:42:24 | C++ | UTF-8 | C++ | false | false | 2,746 | cpp | /*
* Copyright 2010-2017 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
#include <aws/lex-models/model/IntentMetadata.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <utility>
using namespace Aws::Utils::Json;
using namespace Aws::Utils;
namespace Aws
{
namespace LexModelBuildingService
{
namespace Model
{
IntentMetadata::IntentMetadata() :
m_nameHasBeenSet(false),
m_descriptionHasBeenSet(false),
m_lastUpdatedDateHasBeenSet(false),
m_createdDateHasBeenSet(false),
m_versionHasBeenSet(false)
{
}
IntentMetadata::IntentMetadata(const JsonValue& jsonValue) :
m_nameHasBeenSet(false),
m_descriptionHasBeenSet(false),
m_lastUpdatedDateHasBeenSet(false),
m_createdDateHasBeenSet(false),
m_versionHasBeenSet(false)
{
*this = jsonValue;
}
IntentMetadata& IntentMetadata::operator =(const JsonValue& jsonValue)
{
if(jsonValue.ValueExists("name"))
{
m_name = jsonValue.GetString("name");
m_nameHasBeenSet = true;
}
if(jsonValue.ValueExists("description"))
{
m_description = jsonValue.GetString("description");
m_descriptionHasBeenSet = true;
}
if(jsonValue.ValueExists("lastUpdatedDate"))
{
m_lastUpdatedDate = jsonValue.GetDouble("lastUpdatedDate");
m_lastUpdatedDateHasBeenSet = true;
}
if(jsonValue.ValueExists("createdDate"))
{
m_createdDate = jsonValue.GetDouble("createdDate");
m_createdDateHasBeenSet = true;
}
if(jsonValue.ValueExists("version"))
{
m_version = jsonValue.GetString("version");
m_versionHasBeenSet = true;
}
return *this;
}
JsonValue IntentMetadata::Jsonize() const
{
JsonValue payload;
if(m_nameHasBeenSet)
{
payload.WithString("name", m_name);
}
if(m_descriptionHasBeenSet)
{
payload.WithString("description", m_description);
}
if(m_lastUpdatedDateHasBeenSet)
{
payload.WithDouble("lastUpdatedDate", m_lastUpdatedDate.SecondsWithMSPrecision());
}
if(m_createdDateHasBeenSet)
{
payload.WithDouble("createdDate", m_createdDate.SecondsWithMSPrecision());
}
if(m_versionHasBeenSet)
{
payload.WithString("version", m_version);
}
return payload;
}
} // namespace Model
} // namespace LexModelBuildingService
} // namespace Aws | [
"Kent_Chiang@trend.com.tw"
] | Kent_Chiang@trend.com.tw |
389a79ad9458d71e1e88a2fdd7b767600d519907 | 52cbf6068b0005d64172460ff7082e4c71f89e5e | /c++/226_invert_binary_tree.cpp | 9db59c6bbfe068125c9b656f8369bbe2cbc1fd0f | [] | no_license | hatlonely/leetcode-2018 | d2efe08b86871735b1c48697adb9347501df7c08 | 57217059f04898cb41b76682e94f401ee4839d05 | refs/heads/master | 2021-12-09T02:03:38.983512 | 2021-10-31T03:52:23 | 2021-10-31T03:52:23 | 144,447,729 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 457 | cpp | #include <gtest/gtest.h>
#include <iostream>
#include "treenode.hpp"
class Solution {
public:
TreeNode* invertTree(TreeNode* root) {
if (root == nullptr) {
return nullptr;
}
std::swap(root->left, root->right);
invertTree(root->left);
invertTree(root->right);
return root;
}
};
int main(int argc, char* argv[]) {
testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}
| [
"hatlonely@gmail.com"
] | hatlonely@gmail.com |
6deb011a9557b67c2d6c73cc23529d579a649658 | 5ac29efb745daf55c1498e0a49568e277e3416eb | /libstreetmap/tests/m1_func_spatial_toronto_canada_public.cpp | 5dcd356a86044ebf3f3c99ecc59cb645664f05d1 | [] | no_license | LeoMoonStar/mapper | ba1e6b62f7880bc238d3eda11f312dc3fbf72fdf | f945eee52820dc4f5a6d332319a91de73c25909d | refs/heads/master | 2020-08-30T09:58:59.078199 | 2019-10-31T00:21:43 | 2019-10-31T00:21:43 | 87,156,326 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 11,046 | cpp | #include <algorithm>
#include <set>
#include <unittest++/UnitTest++.h>
#include "m1.h"
#include "unit_test_util.h"
#include "StreetsDatabaseAPI.h"
using ece297test::relative_error;
struct MapFixture {
MapFixture() {
//Load the map
load_map("/cad2/ece297s/public/maps/toronto_canada.streets.bin");
}
~MapFixture() {
//Clean-up
close_map();
}
};
SUITE(spatial_queries_public_toronto_canada) {
TEST_FIXTURE(MapFixture, closest_poi) {
std::set<unsigned> valid_results;
unsigned actual;
valid_results = {368};
actual = find_closest_point_of_interest(LatLon(43.64250946044922, -79.35969543457031));
CHECK(valid_results.count(actual));
valid_results = {723};
actual = find_closest_point_of_interest(LatLon(43.71545028686523, -79.45131683349609));
CHECK(valid_results.count(actual));
valid_results = {1091};
actual = find_closest_point_of_interest(LatLon(43.85248184204102, -79.43147277832031));
CHECK(valid_results.count(actual));
valid_results = {1098};
actual = find_closest_point_of_interest(LatLon(43.77970123291016, -79.60785675048828));
CHECK(valid_results.count(actual));
valid_results = {1126};
actual = find_closest_point_of_interest(LatLon(43.8380126953125, -79.22557830810547));
CHECK(valid_results.count(actual));
valid_results = {1224};
actual = find_closest_point_of_interest(LatLon(43.77691268920898, -79.58845520019531));
CHECK(valid_results.count(actual));
valid_results = {1455};
actual = find_closest_point_of_interest(LatLon(43.65697860717773, -79.70158386230469));
CHECK(valid_results.count(actual));
valid_results = {2434};
actual = find_closest_point_of_interest(LatLon(43.56536483764648, -79.34043121337891));
CHECK(valid_results.count(actual));
valid_results = {2489};
actual = find_closest_point_of_interest(LatLon(43.71529388427734, -79.55553436279297));
CHECK(valid_results.count(actual));
valid_results = {4203, 5753};
actual = find_closest_point_of_interest(LatLon(43.74922943115234, -79.02179718017578));
CHECK(valid_results.count(actual));
valid_results = {4982};
actual = find_closest_point_of_interest(LatLon(43.77373886108398, -79.47676086425781));
CHECK(valid_results.count(actual));
valid_results = {5037};
actual = find_closest_point_of_interest(LatLon(43.7193603515625, -79.52051544189453));
CHECK(valid_results.count(actual));
valid_results = {5208};
actual = find_closest_point_of_interest(LatLon(43.87590789794922, -79.01165771484375));
CHECK(valid_results.count(actual));
valid_results = {5228};
actual = find_closest_point_of_interest(LatLon(43.5703125, -79.68901062011719));
CHECK(valid_results.count(actual));
valid_results = {5506};
actual = find_closest_point_of_interest(LatLon(43.87495422363281, -79.56262969970703));
CHECK(valid_results.count(actual));
valid_results = {5516};
actual = find_closest_point_of_interest(LatLon(43.90193939208984, -79.57024383544922));
CHECK(valid_results.count(actual));
valid_results = {6005};
actual = find_closest_point_of_interest(LatLon(43.56804275512695, -79.77233123779297));
CHECK(valid_results.count(actual));
valid_results = {6118};
actual = find_closest_point_of_interest(LatLon(43.69831466674805, -79.65619659423828));
CHECK(valid_results.count(actual));
valid_results = {6409};
actual = find_closest_point_of_interest(LatLon(43.7325325012207, -79.09117126464844));
CHECK(valid_results.count(actual));
valid_results = {6498};
actual = find_closest_point_of_interest(LatLon(43.81575393676758, -79.77579498291016));
CHECK(valid_results.count(actual));
valid_results = {6687};
actual = find_closest_point_of_interest(LatLon(43.48199844360352, -79.40149688720703));
CHECK(valid_results.count(actual));
valid_results = {6687};
actual = find_closest_point_of_interest(LatLon(43.59196853637695, -79.37844085693359));
CHECK(valid_results.count(actual));
valid_results = {6848};
actual = find_closest_point_of_interest(LatLon(43.82280349731445, -79.18561553955078));
CHECK(valid_results.count(actual));
valid_results = {6941};
actual = find_closest_point_of_interest(LatLon(43.71036148071289, -79.60934448242188));
CHECK(valid_results.count(actual));
valid_results = {7207};
actual = find_closest_point_of_interest(LatLon(43.73324203491211, -79.53833770751953));
CHECK(valid_results.count(actual));
valid_results = {7337};
actual = find_closest_point_of_interest(LatLon(43.83701705932617, -79.14602661132812));
CHECK(valid_results.count(actual));
valid_results = {8278};
actual = find_closest_point_of_interest(LatLon(43.58732604980469, -79.09316253662109));
CHECK(valid_results.count(actual));
valid_results = {8392};
actual = find_closest_point_of_interest(LatLon(43.60358428955078, -79.29006958007812));
CHECK(valid_results.count(actual));
valid_results = {8427};
actual = find_closest_point_of_interest(LatLon(43.91736602783203, -79.71571350097656));
CHECK(valid_results.count(actual));
valid_results = {8455};
actual = find_closest_point_of_interest(LatLon(43.89463424682617, -79.20743560791016));
CHECK(valid_results.count(actual));
} //closest_poi
TEST_FIXTURE(MapFixture, closest_intersection) {
std::set<unsigned> valid_results;
unsigned actual;
valid_results = {2136};
actual = find_closest_intersection(LatLon(43.7193603515625, -79.52051544189453));
CHECK(valid_results.count(actual));
valid_results = {4253};
actual = find_closest_intersection(LatLon(43.77373886108398, -79.47676086425781));
CHECK(valid_results.count(actual));
valid_results = {6084, 6093, 6100, 6101, 97673};
actual = find_closest_intersection(LatLon(43.48199844360352, -79.40149688720703));
CHECK(valid_results.count(actual));
valid_results = {7137};
actual = find_closest_intersection(LatLon(43.7325325012207, -79.09117126464844));
CHECK(valid_results.count(actual));
valid_results = {10260};
actual = find_closest_intersection(LatLon(43.82280349731445, -79.18561553955078));
CHECK(valid_results.count(actual));
valid_results = {10432};
actual = find_closest_intersection(LatLon(43.83701705932617, -79.14602661132812));
CHECK(valid_results.count(actual));
valid_results = {10545};
actual = find_closest_intersection(LatLon(43.60358428955078, -79.29006958007812));
CHECK(valid_results.count(actual));
valid_results = {10549};
actual = find_closest_intersection(LatLon(43.56536483764648, -79.34043121337891));
CHECK(valid_results.count(actual));
valid_results = {21784};
actual = find_closest_intersection(LatLon(43.71036148071289, -79.60934448242188));
CHECK(valid_results.count(actual));
valid_results = {28348};
actual = find_closest_intersection(LatLon(43.71545028686523, -79.45131683349609));
CHECK(valid_results.count(actual));
valid_results = {34716};
actual = find_closest_intersection(LatLon(43.69831466674805, -79.65619659423828));
CHECK(valid_results.count(actual));
valid_results = {41421};
actual = find_closest_intersection(LatLon(43.90193939208984, -79.57024383544922));
CHECK(valid_results.count(actual));
valid_results = {42815};
actual = find_closest_intersection(LatLon(43.90982437133789, -79.60358428955078));
CHECK(valid_results.count(actual));
valid_results = {42935};
actual = find_closest_intersection(LatLon(43.77970123291016, -79.60785675048828));
CHECK(valid_results.count(actual));
valid_results = {43170};
actual = find_closest_intersection(LatLon(43.91736602783203, -79.71571350097656));
CHECK(valid_results.count(actual));
valid_results = {43259};
actual = find_closest_intersection(LatLon(43.81575393676758, -79.77579498291016));
CHECK(valid_results.count(actual));
valid_results = {43659};
actual = find_closest_intersection(LatLon(43.77691268920898, -79.58845520019531));
CHECK(valid_results.count(actual));
valid_results = {45565, 96913};
actual = find_closest_intersection(LatLon(43.74922943115234, -79.02179718017578));
CHECK(valid_results.count(actual));
valid_results = {57597};
actual = find_closest_intersection(LatLon(43.73324203491211, -79.53833770751953));
CHECK(valid_results.count(actual));
valid_results = {65218};
actual = find_closest_intersection(LatLon(43.56804275512695, -79.77233123779297));
CHECK(valid_results.count(actual));
valid_results = {66201};
actual = find_closest_intersection(LatLon(43.5703125, -79.68901062011719));
CHECK(valid_results.count(actual));
valid_results = {71302};
actual = find_closest_intersection(LatLon(43.58732604980469, -79.09316253662109));
CHECK(valid_results.count(actual));
valid_results = {71564};
actual = find_closest_intersection(LatLon(43.71529388427734, -79.55553436279297));
CHECK(valid_results.count(actual));
valid_results = {75116};
actual = find_closest_intersection(LatLon(43.8380126953125, -79.22557830810547));
CHECK(valid_results.count(actual));
valid_results = {83449};
actual = find_closest_intersection(LatLon(43.87590789794922, -79.01165771484375));
CHECK(valid_results.count(actual));
valid_results = {83714};
actual = find_closest_intersection(LatLon(43.89463424682617, -79.20743560791016));
CHECK(valid_results.count(actual));
valid_results = {87011};
actual = find_closest_intersection(LatLon(43.85248184204102, -79.43147277832031));
CHECK(valid_results.count(actual));
valid_results = {91612};
actual = find_closest_intersection(LatLon(43.87495422363281, -79.56262969970703));
CHECK(valid_results.count(actual));
valid_results = {103748};
actual = find_closest_intersection(LatLon(43.65697860717773, -79.70158386230469));
CHECK(valid_results.count(actual));
valid_results = {107411};
actual = find_closest_intersection(LatLon(43.64250946044922, -79.35969543457031));
CHECK(valid_results.count(actual));
} //closest_intersection
} //spatial_queries_public_toronto_canada
| [
"jiawei.yang@mail.utoronto.ca"
] | jiawei.yang@mail.utoronto.ca |
4e469f2f7f2e2821131d5c7d48b09394d3f7be06 | edab58696afb07657232f17490b24c8e1e11b6c2 | /miscellanious/lt.cpp | 8c36783f45a51005e26c3d4bad2b5040b9aa40a8 | [] | no_license | mhcayan/competitive-programming | cd8e08da67138cfbdcd2d47cd70572a7fc6435fd | f80ab6929a5d2eb780d35679688ea39138cf9e8a | refs/heads/master | 2022-05-27T15:03:46.147224 | 2022-05-22T00:21:29 | 2022-05-22T00:21:29 | 161,851,714 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,427 | cpp | #include<stdio.h>
#include<string.h>
#include<time.h>
long a[1800][1800],m,n;
char b[1800][1800];
long length_lcs(char a[],char b[]);
void print_lcs(char *x,long i,long j);
int main()
{
long len;
clock_t s,e;
char x[1800][100],y[1800][100];
printf("______Enter two null string to terminate______\n");
for(long i=0; ;i++)
{
printf("Enter string 1:\n");
gets(x[i]);
printf("Enter string 2:\n");
gets(y[i]);
if(strlen(x[i])==0 && strlen(y[i])==0)
break;
}
i=0;
s=clock();
while(strlen(x[i])!=0 && strlen(y[i])!=0)
{
len=length_lcs(x[i],y[i]);
// printf("Length of LCS = %ld\n",len);
// printf("LCS is \"");
print_lcs(x[i],m,n);
// printf("\"\n");
i++;
}
e=clock();
printf("Run time=%ld\n",(e-s));
return 0;
}
long length_lcs(char x[],char y[])
{
long i,j;
m=strlen(x);
n=strlen(y);
for(i=0;i<=m;i++)
a[i][0]=0;
for(i=0;i<=n;i++)
a[0][i]=0;
for(i=1;i<=m;i++)
for(j=1;j<=n;j++)
{
if(x[i-1]==y[j-1])
{
a[i][j]=a[i-1][j-1]+1;
b[i][j]='c';
}
else if(a[i-1][j]>=a[i][j-1])
{
a[i][j]=a[i-1][j];
b[i][j]='u';
}
else
{
a[i][j]=a[i][j-1];
b[i][j]='s';
}
}
return a[i-1][j-1];
}
void print_lcs(char x[1000],long i,long j)
{
if(i==0 || j==0)
return;
if(b[i][j]=='c')
{
print_lcs(x,i-1,j-1);
//printf("%c",x[i-1]);
}
else if(b[i][j]=='u')
print_lcs(x,i-1,j);
else
print_lcs(x,i,j-1);
}
| [
"ayanctg@gmail.com"
] | ayanctg@gmail.com |
4a168c6094027e000056d0c4ccde86cd226a3ca5 | 4fc88d77990c51a3ac4ecd39755d2e448c2dcff4 | /loopback/main.cpp | bb67458e3a59feeac1a86fde846a09007a5316ce | [] | no_license | linzheming/qt_network_demo | 0c2ab8343891063212b59f4577d7a78b44bd8f40 | 678dfb85f7b35e5f3ff740d26274a12dc046ff04 | refs/heads/master | 2022-06-23T09:49:27.881093 | 2020-05-11T09:32:45 | 2020-05-11T09:32:45 | 262,997,298 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,662 | cpp | /****************************************************************************
**
** Copyright (C) 2016 The Qt Company Ltd.
** Contact: https://www.qt.io/licensing/
**
** This file is part of the examples of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:BSD$
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and The Qt Company. For licensing terms
** and conditions see https://www.qt.io/terms-conditions. For further
** information use the contact form at https://www.qt.io/contact-us.
**
** BSD License Usage
** Alternatively, you may use this file under the terms of the BSD license
** as follows:
**
** "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 Qt Company 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
** 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."
**
** $QT_END_LICENSE$
**
****************************************************************************/
#include "dialog.h"
#include <QApplication>
int main(int argc, char *argv[])
{
QApplication app(argc, argv);
Dialog dialog;
dialog.show();
dialog.startServer();
return app.exec();
}
| [
"zhezhelin618@gmail.com"
] | zhezhelin618@gmail.com |
a3eed2161f9982caf7d393bfe6a5b717471f25a9 | f13bcf309973ed4713ef39067e7746f474ab8077 | /src/slice.h | 3e3eaf2a884b1f8f41de4e349109a17b69479708 | [] | no_license | ForeverDavid/MedicalVisualization | ab84a76b7232ff40e187d354fee22a16f26ac599 | 55dfd09d40cbe3b2e719daf847d85057c78f9cad | refs/heads/master | 2020-04-06T16:48:16.902837 | 2018-11-14T18:10:23 | 2018-11-14T18:10:23 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 901 | h | #ifndef SLICE_H
#define SLICE_H
#include <string>
#include "window.h"
#include "imagedata.h"
using namespace std;
class Volume;
class Slice
{
public:
Slice(int type);
virtual void render(Window *window) = 0;
virtual void setImageDataVolume(ImageData* data, Volume* volume) = 0;
virtual void createSlice() = 0;
virtual void updateSlice() = 0;
virtual int getType()=0;
virtual double getPosition() = 0;
virtual void updateTransferFunction() = 0;
virtual vector<double> intensity() = 0;
virtual void createHistogram() = 0;
virtual vector< vector<double> > getPointsOnSlice() =0;
virtual vector< double> getIntensityRange() =0;
virtual void setSliceMode(bool status) = 0;
virtual bool getSliceMode() = 0;
protected:
int type; //1 for axial, 2 for coronal, 3 for sagittal
vector< vector<double> > points_on_slice;
};
#endif // SLICE_H
| [
"megha199501@gmail.com"
] | megha199501@gmail.com |
62ba81bfbcd5c8d8f3a0f1ce85f03cae653ff48b | 9f520bcbde8a70e14d5870fd9a88c0989a8fcd61 | /pitzDaily/913/U | e4ce7f0ab54e9f94e1c68c9eb891221611ba4988 | [] | no_license | asAmrita/adjoinShapOptimization | 6d47c89fb14d090941da706bd7c39004f515cfea | 079cbec87529be37f81cca3ea8b28c50b9ceb8c5 | refs/heads/master | 2020-08-06T21:32:45.429939 | 2019-10-06T09:58:20 | 2019-10-06T09:58:20 | 213,144,901 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 251,118 | /*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: v1806 |
| \\ / A nd | Web: www.OpenFOAM.com |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class volVectorField;
location "913";
object U;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
dimensions [0 1 -1 0 0 0 0];
internalField nonuniform List<vector>
6400
(
(-0.00012040921564 -0.000155833228194 0)
(-0.000315607574987 -0.000111422856636 0)
(-0.000455561257478 -8.53887785745e-05 0)
(-0.000600634461722 -7.26382652937e-05 0)
(-0.000708092971614 -4.69798937077e-05 0)
(-0.000787164458837 -2.80484460748e-05 0)
(-0.000835056079354 -2.05847611893e-05 0)
(-0.000876036646792 -2.91546160521e-05 0)
(-0.00096164944887 -3.87274372102e-05 0)
(-0.00104419939095 -3.62191060137e-05 0)
(-0.00108884907091 -3.23178742951e-05 0)
(-0.0011617819465 -3.2609542585e-05 0)
(-0.00122768422096 -2.88103740609e-05 0)
(-0.00128085636564 -2.3412698121e-05 0)
(-0.001321885467 -2.10017998271e-05 0)
(-0.00136348709425 -2.29749837632e-05 0)
(-0.00141193598241 -2.33271651858e-05 0)
(-0.00145441737529 -2.03077214309e-05 0)
(-0.00148791739452 -1.65566278926e-05 0)
(-0.00152072021621 -1.52181397652e-05 0)
(-0.00156037374959 -1.88821302016e-05 0)
(-0.00160490346902 -2.22997006547e-05 0)
(-0.0016490659607 -2.21201058801e-05 0)
(-0.00168813269323 -2.04455835793e-05 0)
(-0.00172377336677 -1.8251836806e-05 0)
(-0.00175741597236 -1.60458328343e-05 0)
(-0.00178982698502 -1.46761771223e-05 0)
(-0.00181881107572 -1.30855291962e-05 0)
(-0.00184308924218 -1.11767888444e-05 0)
(-0.00186319109022 -9.66066023349e-06 0)
(-0.00187963149298 -8.96459796664e-06 0)
(-0.00189577718385 -7.98832734788e-06 0)
(-0.00191163230122 -6.58200771332e-06 0)
(-0.00192473486218 -6.18961211943e-06 0)
(-0.00193679996845 -5.88370581043e-06 0)
(-0.00195100473654 -5.34746788289e-06 0)
(-0.00196167049937 -5.03937697821e-06 0)
(-0.00196527123298 -4.10923407041e-06 0)
(-0.00197313147753 -2.4934453551e-06 0)
(-0.00198276681703 -1.01829986551e-06 0)
(-0.00198508911928 -6.78541298948e-07 0)
(-0.00197910144854 5.43819807142e-07 0)
(-0.00197075803562 3.70634792336e-06 0)
(-0.00196152400763 6.10588605457e-06 0)
(-0.00194914417978 7.5490742965e-06 0)
(-0.00193343587835 9.16983677029e-06 0)
(-0.00191407382719 1.09848212964e-05 0)
(-0.00189045627464 1.31645763308e-05 0)
(-0.00186251694057 1.53815975576e-05 0)
(-0.0018299640796 1.66070413817e-05 0)
(-0.00179416360018 1.67979548327e-05 0)
(-0.00175782335711 1.87465812728e-05 0)
(-0.00171577392645 2.40491432306e-05 0)
(-0.00166855728637 2.80763369303e-05 0)
(-0.00160942076364 3.19303056725e-05 0)
(-0.00153465181533 3.68974987012e-05 0)
(-0.00145643105843 3.82838910447e-05 0)
(-0.00138376705845 3.89455114232e-05 0)
(-0.00130646349437 4.32827783131e-05 0)
(-0.00120991179007 4.72799461784e-05 0)
(-0.001109268065 4.90489874876e-05 0)
(-0.0010065915618 5.66006071005e-05 0)
(-0.000911489333507 7.27607077017e-05 0)
(-0.000767435112226 8.38173646555e-05 0)
(-0.000568138431555 6.89886419551e-05 0)
(-0.000430416994982 4.97787648376e-05 0)
(-0.000348761510799 4.15516491214e-05 0)
(-0.000283755810412 3.69107897047e-05 0)
(-0.000221021209381 3.43697654948e-05 0)
(-0.000155360667845 3.18537213077e-05 0)
(-9.48472887518e-05 2.7854612347e-05 0)
(-4.34412382787e-05 2.1834386172e-05 0)
(-7.37786651547e-06 1.55674211092e-05 0)
(1.76121582579e-05 9.78142821585e-06 0)
(2.92046778963e-05 4.26570735988e-06 0)
(3.79278906952e-05 1.05843234423e-06 0)
(3.16423145878e-05 -3.74759085181e-07 0)
(3.86245175972e-05 -3.4262975996e-06 0)
(1.82133621025e-05 -3.78224283872e-06 0)
(1.41146280123e-05 -8.15170012602e-06 0)
(-4.66958579087e-05 -0.000224349290291 0)
(-0.000196293815212 -0.000245057592434 0)
(-0.000338976340531 -0.000214380971392 0)
(-0.000433593522947 -0.000171564528805 0)
(-0.000609802764223 -0.000163972337309 0)
(-0.000757869171453 -0.000115530539019 0)
(-0.000844776382209 -7.6848142408e-05 0)
(-0.000906758958849 -9.24609570479e-05 0)
(-0.000972156469386 -0.000112676397974 0)
(-0.00104335501784 -0.000108878507924 0)
(-0.00110993782688 -9.99315150309e-05 0)
(-0.00117070014463 -9.39807037446e-05 0)
(-0.00122677809859 -8.2626605924e-05 0)
(-0.00127644989691 -6.98663688388e-05 0)
(-0.00132353569294 -6.39462257292e-05 0)
(-0.00136772030636 -7.15547188199e-05 0)
(-0.00141218904979 -7.38833455129e-05 0)
(-0.00145057414675 -5.74632517372e-05 0)
(-0.00146501869677 -4.5187728742e-05 0)
(-0.00150440751856 -4.66114990867e-05 0)
(-0.00155291180909 -5.84121653877e-05 0)
(-0.00160153931718 -7.0017641023e-05 0)
(-0.00165063652325 -6.8809793995e-05 0)
(-0.00169190794893 -6.01640405276e-05 0)
(-0.00172112815971 -5.34593315587e-05 0)
(-0.00175783525531 -4.92196599648e-05 0)
(-0.00179173154931 -4.44289450364e-05 0)
(-0.00181933769342 -3.88399474809e-05 0)
(-0.00184299219041 -3.35071689156e-05 0)
(-0.00186385661136 -2.92077340516e-05 0)
(-0.00188136569961 -2.64714297946e-05 0)
(-0.00189410993533 -2.33108254008e-05 0)
(-0.00190998166298 -1.90311128751e-05 0)
(-0.00192263488949 -1.83436311717e-05 0)
(-0.0019334268712 -1.87262178811e-05 0)
(-0.00195127672909 -1.61383845487e-05 0)
(-0.0019602798339 -1.46469733238e-05 0)
(-0.00196377524467 -1.33201550649e-05 0)
(-0.00197395684694 -9.55021040445e-06 0)
(-0.00198810961624 -3.89282450906e-06 0)
(-0.00199130365458 3.22461104522e-06 0)
(-0.00196761337273 9.49750728428e-06 0)
(-0.00194995086151 1.36578880228e-05 0)
(-0.00194335865803 1.69498974413e-05 0)
(-0.00193279142912 2.0597669719e-05 0)
(-0.00192011107217 2.51267917274e-05 0)
(-0.00190446423312 3.06298943789e-05 0)
(-0.00188338514523 3.68545144941e-05 0)
(-0.00186011305647 4.35198720665e-05 0)
(-0.00183161524186 4.99535002812e-05 0)
(-0.0017937033572 5.54385403124e-05 0)
(-0.00174307075944 6.06266660938e-05 0)
(-0.00169503674718 6.74128037308e-05 0)
(-0.00166787332221 7.92245880883e-05 0)
(-0.00160477007773 9.40967041358e-05 0)
(-0.00153510104423 0.000105988010919 0)
(-0.00147222592968 0.000112506106078 0)
(-0.00139744640895 0.000119083806247 0)
(-0.0013123028811 0.000130831186014 0)
(-0.00122104114385 0.000144262232325 0)
(-0.00111889757384 0.00015741741729 0)
(-0.00099049931294 0.000174808640756 0)
(-0.000892648851866 0.000217506478564 0)
(-0.000744012406258 0.000251665215567 0)
(-0.000562151957563 0.000223614754365 0)
(-0.000404775940609 0.000157389372174 0)
(-0.000312530868414 0.000116144664625 0)
(-0.000259806448098 0.000104465942075 0)
(-0.000199132050103 0.000100560063885 0)
(-0.000139540566492 9.73537262239e-05 0)
(-7.99853917183e-05 8.5302777267e-05 0)
(-3.09240734805e-05 6.49003322942e-05 0)
(3.34473814169e-06 4.26539255343e-05 0)
(2.68255227666e-05 2.7621832078e-05 0)
(4.09388971865e-05 1.45730702381e-05 0)
(4.79673711001e-05 4.5735184216e-06 0)
(4.85333139909e-05 -2.20018011448e-06 0)
(4.43881976608e-05 -1.08887939844e-05 0)
(2.96163635509e-05 -1.77656644076e-05 0)
(1.4485690427e-05 -3.42779890712e-05 0)
(-6.65893026335e-05 -0.000386173864645 0)
(-0.000186176446209 -0.000408753911007 0)
(-0.000290043441979 -0.000370642722698 -8.24713796908e-29)
(-0.000471779917756 -0.000359792764102 7.47194217533e-29)
(-0.00063474429981 -0.000342914896573 6.43582027922e-29)
(-0.000744737637258 -0.000272979776883 -5.81294888674e-29)
(-0.00082648375804 -0.000153038614304 5.76346892786e-29)
(-0.000891424785276 -0.000155865741752 -5.49507225415e-29)
(-0.000958589981651 -0.000184490308787 0)
(-0.00103369364747 -0.000183627893278 0)
(-0.00110598825188 -0.000169300380309 0)
(-0.00116972861157 -0.000152110619798 0)
(-0.00122603503388 -0.000133062806422 0)
(-0.0012747562127 -0.000118469041209 0)
(-0.00132381407573 -0.000110517161517 0)
(-0.00136930906936 -0.000101045759583 0)
(-0.00132006628162 -8.29886429591e-05 0)
(-0.00130999279431 -7.14649947967e-05 0)
(-0.00135558106169 -8.05275425021e-05 0)
(-0.00143263951406 -0.000106206783106 0)
(-0.00155109422359 -0.000126133480607 0)
(-0.00161395301605 -0.000124761819598 0)
(-0.00164562329043 -0.000112661432167 0)
(-0.00168669814377 -9.97426558031e-05 0)
(-0.00172734231255 -8.99954643098e-05 0)
(-0.0017605240917 -8.23325301271e-05 0)
(-0.00179078079624 -7.34393774284e-05 0)
(-0.00181877601954 -6.42195285337e-05 0)
(-0.00184303313718 -5.58775358912e-05 0)
(-0.00186345693446 -4.90321395126e-05 -9.41333118436e-29)
(-0.00188236725534 -4.31128402984e-05 9.071319984e-29)
(-0.00189198679891 -3.77326637382e-05 0)
(-0.00190708520248 -3.20734493852e-05 0)
(-0.00192717372791 -2.82310030466e-05 0)
(-0.00192592137546 -3.03030814342e-05 0)
(-0.00194435573712 -2.99793895527e-05 0)
(-0.00196498002187 -2.45327272757e-05 0)
(-0.00196174878012 -2.1709628913e-05 0)
(-0.00197252577135 -1.89411093878e-05 0)
(-0.00198727261434 -9.11162996455e-06 0)
(-0.00199103188431 6.91904204705e-06 0)
(-0.00198429415237 1.94698175906e-05 0)
(-0.00197480210785 2.44452157252e-05 0)
(-0.00196490760478 2.8189463864e-05 0)
(-0.00195225159093 3.403850751e-05 0)
(-0.00193609026011 4.14966935074e-05 0)
(-0.00191644458115 5.04633210174e-05 0)
(-0.00189318458423 6.03396583866e-05 0)
(-0.00186631195489 7.10724810666e-05 0)
(-0.00183536008502 8.30367796895e-05 0)
(-0.00179964596107 9.5233298938e-05 0)
(-0.00175926967148 0.000105336985012 0)
(-0.00171489262439 0.000114455893516 0)
(-0.00166120929912 0.000131379891584 0)
(-0.00159787378559 0.000153067577972 0)
(-0.0015380286491 0.000170232831676 0)
(-0.00147086689943 0.00018478826909 0)
(-0.00139204795627 0.000201477330905 0)
(-0.00130360242107 0.000221305997461 0)
(-0.00120589908663 0.000244139920197 0)
(-0.00109519972318 0.000271904348653 0)
(-0.000978669624176 0.000312267034985 0)
(-0.000851163653188 0.000379784578576 0)
(-0.000679327779093 0.00041399191328 0)
(-0.00048584795463 0.000340801567049 0)
(-0.000368926191885 0.000257380277004 0)
(-0.000293177051096 0.00020404923743 0)
(-0.000222313449964 0.000173951549714 0)
(-0.000160377194532 0.0001621784585 0)
(-0.000102309025248 0.000151592378817 0)
(-4.8494952615e-05 0.000129645361829 0)
(-5.18699907176e-06 9.94856165695e-05 0)
(2.73135647538e-05 7.2848366317e-05 0)
(4.90694030457e-05 4.79368704348e-05 0)
(5.84935415711e-05 2.4356371681e-05 0)
(6.1289752275e-05 7.30182094879e-06 0)
(5.90708437644e-05 -5.55084423839e-06 0)
(5.16364312565e-05 -2.26044306968e-05 0)
(3.83685568787e-05 -4.5870091366e-05 0)
(1.05920953356e-05 -5.20376202155e-05 0)
(-6.55372853443e-05 -0.000561255967676 0)
(-9.72261374065e-05 -0.00039893443867 0)
(-0.000236784842605 -0.000550018785475 0)
(-0.000403822116896 -0.000531529947543 0)
(-0.000560898651329 -0.000450484986902 0)
(-0.000364003538489 -0.000195586174112 0)
(-0.000464195297535 -0.000194401484899 0)
(-0.00079043309389 -0.000306539911857 0)
(-0.000917028562266 -0.000301473002283 0)
(-0.00101185902011 -0.000270800610824 0)
(-0.00109575314968 -0.000244789508877 0)
(-0.0011667848364 -0.000216140568485 0)
(-0.00122737830908 -0.000187215195276 0)
(-0.00127214329962 -0.000153188624278 0)
(-0.00125350730975 -0.000114457855417 0)
(-0.00122834057979 -8.95541387396e-05 0)
(-0.00124134665991 -8.89503023896e-05 0)
(-0.00130633500256 -0.000119703059986 0)
(-0.00142455072086 -0.000164474974111 0)
(-0.00152084006628 -0.000195997513675 0)
(-0.00156401362186 -0.000193692760694 0)
(-0.00160778185459 -0.000173593733335 0)
(-0.00165221520944 -0.000155092325286 0)
(-0.00169147168243 -0.000140226801627 0)
(-0.00172704615916 -0.000126470973518 0)
(-0.00175941341591 -0.000113738480971 0)
(-0.00178916823982 -0.000101850617346 0)
(-0.00181876412702 -8.99569155729e-05 0)
(-0.00184188524382 -7.85074951888e-05 0)
(-0.00186535251776 -6.85182838478e-05 0)
(-0.00187832884544 -5.99094428527e-05 0)
(-0.00189673284296 -5.13710702445e-05 0)
(-0.00190052747956 -4.29209710495e-05 0)
(-0.00191827766915 -4.03847834838e-05 0)
(-0.0019422180275 -4.24261748359e-05 0)
(-0.00194330616994 -4.35960649671e-05 0)
(-0.00196281129526 -3.90063759745e-05 0)
(-0.00198021388975 -3.24946556015e-05 0)
(-0.00198634230848 -2.58324148356e-05 0)
(-0.00198995977775 -1.22808634305e-05 0)
(-0.00199074044517 6.57406374394e-06 0)
(-0.00198648874088 2.25724220669e-05 0)
(-0.00197881233627 3.25051747913e-05 0)
(-0.00196881648875 4.02630479772e-05 0)
(-0.00195573772591 4.92267240713e-05 0)
(-0.00193922086038 5.99594670146e-05 7.71052779944e-29)
(-0.00191922961291 7.22286527977e-05 -7.73569610116e-29)
(-0.00189565084339 8.56872880859e-05 0)
(-0.00186836885157 0.00010027953954 0)
(-0.00183705327607 0.000115926080562 0)
(-0.00180117512731 0.000131836127589 0)
(-0.00176019606453 0.000147551754732 0)
(-0.00171353219414 0.000165482786759 0)
(-0.00165987123183 0.000188472222498 0)
(-0.00160025966363 0.000212885460084 0)
(-0.00153625986849 0.000236156182839 0)
(-0.00146465097301 0.000260753765233 0)
(-0.00138206702783 0.000288079647021 1.38668225837e-28)
(-0.00128780597939 0.000318944609007 -1.58349069822e-28)
(-0.00118073590439 0.00035484493563 0)
(-0.00105896386431 0.000399360476907 0)
(-0.000923849889923 0.000461168239632 0)
(-0.000772900640952 0.000532962520491 0)
(-0.00062229297498 0.000562415837418 0)
(-0.000482476870614 0.000499599714256 0)
(-0.000331896096271 0.000356342948127 0)
(-0.000239232168795 0.000273833736559 0)
(-0.000171415898932 0.000239359862404 0)
(-0.000112057412458 0.000221228794931 0)
(-5.96995799687e-05 0.000208397892343 0)
(-8.77521969138e-06 0.000182489371181 0)
(3.47580355325e-05 0.000143363591981 0)
(6.118196829e-05 9.85029480848e-05 0)
(6.77815498469e-05 5.5387697262e-05 0)
(7.10505247891e-05 2.67832871022e-05 0)
(7.24984741538e-05 5.26766138865e-06 0)
(6.50215376407e-05 -1.56673531374e-05 0)
(4.23089520541e-05 -3.1756824088e-05 0)
(3.22098029273e-05 -5.75405966688e-05 0)
(1.12121675832e-05 -7.49099713525e-05 0)
(-1.28301411042e-05 -0.000579506929941 0)
(-5.63517557207e-05 -0.000484163382209 0)
(-0.00020986621207 -0.000707430573697 0)
(-0.000348122857252 -0.000652610983857 0)
(-0.000407590367542 -0.00045723023169 0)
(-0.000341875903834 -0.000265511433559 0)
(-0.000557583813454 -0.000401083716468 0)
(-0.00076996669979 -0.00049547985052 0)
(-0.000869450220289 -0.000430658719813 0)
(-0.00097980726558 -0.000371488416965 0)
(-0.00107343721203 -0.000334129638973 0)
(-0.00115373681115 -0.000290322243942 0)
(-0.00118669857657 -0.000217415266771 0)
(-0.00114295395956 -0.000142383941882 0)
(-0.00117042925029 -0.000115037331132 0)
(-0.00123123881539 -0.000125759321818 0)
(-0.00132023964556 -0.000165029985637 0)
(-0.00141594202504 -0.000215231085576 0)
(-0.00148211759335 -0.000244851853769 0)
(-0.00151585202775 -0.00024443834316 0)
(-0.00156108229542 -0.000234942785117 0)
(-0.00161026888796 -0.000219593139764 0)
(-0.00165250687063 -0.000199139335402 0)
(-0.00169147458171 -0.000178782327226 0)
(-0.00172655312502 -0.000160737328299 0)
(-0.00175792846757 -0.000145357663245 0)
(-0.00179023983571 -0.000130637253255 0)
(-0.00181486749882 -0.000115878104286 0)
(-0.00184447116945 -0.00010123377931 0)
(-0.00185889995516 -8.72712930054e-05 0)
(-0.00188341167453 -7.54342739869e-05 -9.05403093728e-29)
(-0.00187881005188 -6.48061780157e-05 8.66408660093e-29)
(-0.00190724033389 -5.85500863587e-05 0)
(-0.00193301056913 -5.52413406556e-05 0)
(-0.00193902145743 -5.67516158807e-05 0)
(-0.00196224653013 -5.88252852675e-05 0)
(-0.0019760253368 -5.48437317501e-05 0)
(-0.00198509741761 -4.3560754851e-05 0)
(-0.00199050258776 -2.94436193888e-05 0)
(-0.00199325116941 -1.23296754985e-05 0)
(-0.00199355459749 7.56546978551e-06 0)
(-0.00199031552659 2.58710335589e-05 0)
(-0.00198356489997 3.99922725984e-05 0)
(-0.00197364304741 5.19751247985e-05 0)
(-0.00196034419826 6.45209968729e-05 0)
(-0.00194355903557 7.86193463177e-05 0)
(-0.00192324971651 9.42898477336e-05 0)
(-0.00189929613459 0.000111339114722 0)
(-0.00187151494389 0.000129712894469 0)
(-0.0018395909226 0.000149337053378 0)
(-0.00180302739419 0.000169922782296 0)
(-0.00176115884259 0.000191704767788 0)
(-0.00171326002663 0.000216206403012 0)
(-0.00165879082584 0.000244331065746 0)
(-0.00159827957499 0.000274474377494 0)
(-0.00153148947103 0.000306289849986 0)
(-0.0014552528031 0.000341597620502 0)
(-0.00136609052131 0.00038169625813 0)
(-0.00126179578181 0.000427726814009 0)
(-0.00114035561462 0.000481791677654 0)
(-0.00100105606814 0.000546367206734 0)
(-0.000848560798839 0.000618101140882 0)
(-0.000692556159001 0.000673387441311 0)
(-0.000562984236649 0.000694692547369 0)
(-0.000440818075849 0.000639272812876 0)
(-0.000305216897044 0.000487672881203 0)
(-0.000200983002403 0.000374333006694 0)
(-0.000119703827107 0.000312281393109 0)
(-5.53454030198e-05 0.000277877115742 0)
(-1.43049742592e-06 0.000256919634098 0)
(4.90161854641e-05 0.000229233506507 0)
(8.23375553967e-05 0.000172212650442 0)
(8.63214772215e-05 0.00010236782321 0)
(8.83618757608e-05 5.81748037753e-05 0)
(9.11747051982e-05 2.7357636069e-05 0)
(8.85423942635e-05 -2.64905770299e-06 0)
(7.05513069768e-05 -3.01433859001e-05 0)
(4.9632296119e-05 -4.93531407078e-05 0)
(3.60569592505e-05 -8.1353788547e-05 0)
(1.07194906756e-05 -9.4116232716e-05 0)
(-3.17934799639e-06 -0.000551772027973 0)
(-6.3549166836e-05 -0.000584925685072 0)
(-0.00020772816681 -0.000811897316655 0)
(-0.000301703792489 -0.000701721717802 0)
(-0.000251168439332 -0.000379002380078 0)
(-0.000345423232425 -0.000381843547006 0)
(-0.000644367899492 -0.000615274459957 0)
(-0.000735175145262 -0.00060787909394 0)
(-0.000833170452793 -0.000541273687262 0)
(-0.000941458585518 -0.000480273934612 0)
(-0.00104242914572 -0.000412617708255 0)
(-0.00102841680423 -0.000303718320826 0)
(-0.000977336370455 -0.0001946430865 0)
(-0.00104476925133 -0.000166220558658 0)
(-0.00112676729591 -0.000181582072316 0)
(-0.00125283556956 -0.000225726764443 0)
(-0.00136281178801 -0.000266369553086 0)
(-0.00143418723328 -0.000283199090098 0)
(-0.00146178025589 -0.000281295745831 0)
(-0.00151250301166 -0.000285425467153 0)
(-0.00156651007111 -0.000282899816424 0)
(-0.00161041785566 -0.000264947333199 0)
(-0.00165132854842 -0.000241110143334 0)
(-0.00168926150534 -0.000217579414602 0)
(-0.0017277707966 -0.000195964771911 0)
(-0.00175935222742 -0.000175370443765 0)
(-0.00178067199852 -0.000158733988231 0)
(-0.00181928355218 -0.00014262674221 0)
(-0.00183105950226 -0.000122968883027 0)
(-0.00186672516297 -0.000104222303758 0)
(-0.00185597999762 -8.75984006528e-05 0)
(-0.00189215001889 -8.1707033275e-05 0)
(-0.00188704318639 -7.69511066994e-05 0)
(-0.00192726608744 -7.61484796047e-05 0)
(-0.00195969991785 -7.739337263e-05 0)
(-0.00197410089805 -7.59227441872e-05 0)
(-0.00198329232427 -6.56912886675e-05 0)
(-0.00199042274009 -5.03937328101e-05 0)
(-0.00199528379411 -3.27924562134e-05 0)
(-0.00199791570224 -1.3011568324e-05 0)
(-0.00199813920865 8.51430373799e-06 0)
(-0.00199531485513 2.92011927742e-05 0)
(-0.00198906561069 4.71856413193e-05 0)
(-0.00197929141016 6.34218318872e-05 0)
(-0.00196592719661 7.9837803511e-05 0)
(-0.00194895414247 9.75185686715e-05 0)
(-0.00192834797806 0.000116736070555 0)
(-0.00190395599934 0.000137475316332 0)
(-0.00187553349207 0.000159752786182 0)
(-0.00184275790703 0.000183610393968 0)
(-0.00180516302966 0.000209125024576 0)
(-0.00176211736745 0.000236774050702 0)
(-0.00171297917772 0.000267494197289 0)
(-0.00165732512757 0.000301704100557 0)
(-0.00159485243313 0.00033923184915 0)
(-0.00152395073126 0.000381197248523 0)
(-0.0014409285236 0.000429741333226 0)
(-0.00134181597286 0.000486403682715 0)
(-0.00122376868124 0.000552124561048 0)
(-0.00108546481943 0.000626599403708 0)
(-0.000930576076875 0.000705017463774 0)
(-0.000769458989702 0.00076938381009 0)
(-0.000608101843023 0.000794772139122 0)
(-0.000497519770876 0.000832832209335 0)
(-0.000360444831609 0.00074925520995 0)
(-0.00023964954285 0.000584739151348 0)
(-0.000146275636744 0.000465399740418 0)
(-6.03055015212e-05 0.00038760595044 0)
(1.16911187866e-05 0.000336415844235 0)
(7.2219793194e-05 0.000312303709523 0)
(0.000116802102442 0.0002669579518 0)
(0.000119930467705 0.000173395599224 0)
(0.000113520518082 0.000102027529127 0)
(0.00011672724904 6.01762563904e-05 0)
(0.00011559889158 2.34990691658e-05 0)
(0.000108142937174 -1.66319995793e-05 0)
(8.20017568936e-05 -4.6796414115e-05 0)
(6.10202226025e-05 -6.87901228774e-05 0)
(4.36243096309e-05 -0.000105685296551 0)
(1.35200744464e-05 -0.000117153870153 0)
(-2.24325925792e-05 -0.000602070470339 0)
(-0.000123944244757 -0.000745159492616 0)
(-0.00025697697226 -0.000890398225526 0)
(-0.000309851852365 -0.000839725359536 0)
(-0.000243458036476 -0.000481669190136 0)
(-0.000465643115586 -0.000641083461345 0)
(-0.000641869338653 -0.00074259733447 0)
(-0.000709916571636 -0.000696511655082 0)
(-0.000803940371699 -0.000634427032179 0)
(-0.000878992272427 -0.000571283472213 0)
(-0.00101297753655 -0.000474820397873 2.62168531458e-28)
(-0.00087116056154 -0.000271986210626 -1.7800692253e-28)
(-0.000967866434385 -0.000238507497879 0)
(-0.00102996975435 -0.000246303049404 0)
(-0.00115883501209 -0.000293891379237 0)
(-0.00128974234237 -0.000345936391401 0)
(-0.00137024238347 -0.000349844194705 0)
(-0.00139033241552 -0.00032454111263 0)
(-0.00145220573623 -0.000327414742246 0)
(-0.0015191396981 -0.000338863152319 0)
(-0.00156353060192 -0.00033040459628 0)
(-0.00160858847472 -0.00030878328056 0)
(-0.00165151355833 -0.00028306888362 0)
(-0.00169113355519 -0.000255865252612 0)
(-0.00172243159721 -0.000228468437337 0)
(-0.00174891543374 -0.000203405412298 0)
(-0.00178785529567 -0.000185232407027 0)
(-0.00179287774598 -0.000167660251717 0)
(-0.00184130590596 -0.000145522238872 0)
(-0.00182851188817 -0.000115911102849 0)
(-0.00187431272861 -0.000104720707408 0)
(-0.00186903214942 -0.000101206810178 8.62622259886e-29)
(-0.0019094947958 -0.000100335342425 -8.59233159167e-29)
(-0.00193627401703 -0.000104047011581 0)
(-0.00196960790469 -0.000101875569032 0)
(-0.00198263172947 -9.0124084302e-05 0)
(-0.00199004543075 -7.42549755806e-05 0)
(-0.00199633923718 -5.61220286998e-05 0)
(-0.00200122356304 -3.60509464747e-05 0)
(-0.00200397491567 -1.40196324834e-05 0)
(-0.00200420131101 9.44396843105e-06 0)
(-0.00200155275598 3.26588410651e-05 0)
(-0.00199556602038 5.42854902174e-05 0)
(-0.00198593348381 7.46767220379e-05 0)
(-0.00197256507866 9.5115961893e-05 0)
(-0.00195545579598 0.000116601964798 0)
(-0.00193454036165 0.000139582025519 0)
(-0.00190960433515 0.000164218318856 0)
(-0.001880357551 0.000190633340317 0)
(-0.00184648764988 0.000218998657399 0)
(-0.00180758603659 0.000249612711077 0)
(-0.00176310134861 0.000283042504976 0)
(-0.0017124278569 0.000320054128959 0)
(-0.00165489046098 0.000361372698544 0)
(-0.00158925900787 0.000408169097544 0)
(-0.00151275256944 0.000462821060737 0)
(-0.00142095794764 0.000527972094381 0)
(-0.00130959957005 0.000604729967577 0)
(-0.0011769206306 0.000691411693737 0)
(-0.00102580499793 0.000782368403027 0)
(-0.000863787379854 0.000864668770085 0)
(-0.000702462935819 0.000920173152836 0)
(-0.000555550443752 0.000951464871476 0)
(-0.000429289746322 0.00095183888679 0)
(-0.000301080812179 0.000863464696677 0)
(-0.000165152773402 0.000670543592664 0)
(-7.30775814297e-05 0.000560634425042 0)
(1.49870181226e-05 0.000481802846694 0)
(9.4429145656e-05 0.00041861010078 0)
(0.000155583272133 0.000363436767971 0)
(0.000174562330246 0.000270579408832 0)
(0.000156449494852 0.000163927817491 0)
(0.000150796822924 0.000100843707778 0)
(0.000148286821887 5.79679335149e-05 0)
(0.000144446226371 1.52004622676e-05 0)
(0.000127925861711 -3.22827674236e-05 0)
(0.000105664773464 -6.93356523628e-05 0)
(7.60446724057e-05 -9.28906435258e-05 0)
(5.30503879148e-05 -0.000132899898562 0)
(1.80660528695e-05 -0.000149961587979 0)
(-4.24347182205e-05 -0.000700795587848 0)
(-0.000165426676456 -0.000889032621051 0)
(-0.000281188686683 -0.000940218347996 0)
(-0.000216298629097 -0.000630259868071 0)
(-0.000257544328272 -0.000596844852562 0)
(-0.000511566041482 -0.000843359226616 0)
(-0.000600399750369 -0.000831401664038 0)
(-0.000687992037366 -0.000784720575917 0)
(-0.000759868083402 -0.000711029253783 0)
(-0.000856206336967 -0.000640625318777 0)
(-0.000764936322455 -0.000415981836287 0)
(-0.000860215046042 -0.000326357986367 0)
(-0.000949991051672 -0.000316008982066 0)
(-0.00103081356378 -0.000345266041901 0)
(-0.00120345310966 -0.000421224797766 0)
(-0.00129835563717 -0.000436202742446 0)
(-0.00131134901077 -0.000393285544748 0)
(-0.00137254659199 -0.000378063715245 0)
(-0.00145822171461 -0.000392699075231 0)
(-0.00151591043407 -0.00039294744325 0)
(-0.00155941631466 -0.000375913958019 0)
(-0.00160230220883 -0.000352027642992 0)
(-0.00164757423474 -0.000326396780591 0)
(-0.00168741530636 -0.000295815715547 0)
(-0.00172890343911 -0.000259831720492 0)
(-0.0017427849602 -0.00023349662361 0)
(-0.00179252795874 -0.000211446440219 0)
(-0.00180395797611 -0.00018677573439 0)
(-0.00180563410338 -0.000162386501034 0)
(-0.00183618468402 -0.000142169546002 0)
(-0.00189136594104 -0.000129756978729 0)
(-0.00189156543302 -0.000119815868875 0)
(-0.0019073831843 -0.000128014055253 0)
(-0.00195884365194 -0.000132915599234 0)
(-0.0019767779084 -0.000122571715715 0)
(-0.0019884331103 -0.000102968069462 0)
(-0.00199698827619 -8.24417917985e-05 0)
(-0.0020034364605 -6.16955280546e-05 0)
(-0.00200835280285 -3.94862640087e-05 0)
(-0.00201125821491 -1.53128371255e-05 0)
(-0.00201158260087 1.03304187473e-05 0)
(-0.00200901436956 3.62205414326e-05 0)
(-0.00200317638304 6.13651188333e-05 0)
(-0.00199368393851 8.58085670858e-05 0)
(-0.0019803564404 0.000110361097049 7.51484128621e-29)
(-0.00196313308899 0.000135871173023 -7.48082919959e-29)
(-0.00194186552567 0.000162891021275 0)
(-0.00191625977832 0.000191725644795 0)
(-0.00188599102915 0.000222586936158 0)
(-0.00185077232541 0.00025573833974 0)
(-0.00181025865014 0.000291620129154 0)
(-0.0017639684896 0.000330938597989 0)
(-0.00171125078603 0.000374699693063 0)
(-0.00165102713128 0.000424393214472 0)
(-0.00158118533629 0.000482509862777 0)
(-0.00149800026961 0.000552511250216 0)
(-0.00139660931082 0.000637120074468 0)
(-0.00127344828936 0.000735444675581 0)
(-0.0011297792722 0.00084105468488 0)
(-0.00097164089059 0.00094366653711 0)
(-0.000805870191049 0.00102842482072 0)
(-0.000642141935808 0.00107871982343 0)
(-0.000492442169637 0.00109033750118 0)
(-0.00036367160268 0.00106299875652 0)
(-0.000262427066809 0.00101937562732 0)
(-0.000108529513892 0.000793863690231 0)
(1.2271460402e-05 0.000649462879106 0)
(0.000104616258261 0.000566095653219 0)
(0.000182544923584 0.000482999493574 0)
(0.000233227171873 0.000386624954201 0)
(0.00023110404601 0.00025657866931 0)
(0.000205668731874 0.000150028365886 0)
(0.000191127551317 9.11527964972e-05 0)
(0.000179495351822 5.0965613082e-05 0)
(0.000174157759062 5.89918863882e-06 0)
(0.000157546612711 -4.78172658509e-05 0)
(0.000138277730151 -9.69204204415e-05 0)
(9.93589062061e-05 -0.000128403928037 0)
(6.30057157565e-05 -0.000167510624723 0)
(2.18789897741e-05 -0.000192800010513 0)
(-5.65428180908e-05 -0.000820058895954 0)
(-0.00018163724417 -0.00100339537806 0)
(-0.000247216433668 -0.00098628560092 0)
(-0.000210855179029 -0.000692333304586 0)
(-0.000332073842792 -0.000768678924315 0)
(-0.000514247751655 -0.000949900104324 0)
(-0.000565824400399 -0.000915619376498 0)
(-0.000668525390419 -0.000869323781137 0)
(-0.000683880639719 -0.000745200115039 0)
(-0.000859873646541 -0.00072401030667 0)
(-0.000744898732088 -0.000465509555652 0)
(-0.00086062639617 -0.000414092717409 0)
(-0.000940938840486 -0.00040906327508 0)
(-0.00107806319949 -0.000474130597859 0)
(-0.00120930942766 -0.000533263341906 0)
(-0.00128520387338 -0.000503624405212 0)
(-0.00129961723813 -0.0004453430425 0)
(-0.00137615295116 -0.000447064776553 0)
(-0.00145134355383 -0.000457936781467 0)
(-0.00150755194657 -0.000446795332588 0)
(-0.00155785122255 -0.000422876372034 0)
(-0.00159939056624 -0.000393829880776 0)
(-0.00164285965375 -0.00036594836919 0)
(-0.00166965754291 -0.000334430991331 0)
(-0.00170094757975 -0.000290319338244 0)
(-0.00175653994546 -0.000261238826324 0)
(-0.00174187509097 -0.000236951673542 0)
(-0.00182280878037 -0.000211885126735 0)
(-0.00180558892594 -0.000186610421445 0)
(-0.00187042463984 -0.000174348389258 0)
(-0.00185716343731 -0.000153549779688 0)
(-0.00192012320754 -0.000147715038149 0)
(-0.00194690312352 -0.000155347329893 8.85690912467e-29)
(-0.00196694254247 -0.000156388863249 -8.73154447059e-29)
(-0.00198287194041 -0.000138778886137 0)
(-0.00199516802034 -0.000115012217211 0)
(-0.00200473600779 -9.11586414174e-05 0)
(-0.00201168299668 -6.76516411754e-05 0)
(-0.00201666584025 -4.31683072389e-05 0)
(-0.0020196400538 -1.68409871914e-05 0)
(-0.0020201152861 1.11268688606e-05 0)
(-0.00201768563323 3.98185816568e-05 0)
(-0.00201197574551 6.84275963428e-05 0)
(-0.00200262290899 9.68451242312e-05 0)
(-0.00198938724541 0.000125584508039 0)
(-0.00197207248955 0.000155352500117 0)
(-0.00195039933868 0.000186744868616 0)
(-0.0019239963093 0.000220157692731 0)
(-0.00189251012896 0.000255849188105 0)
(-0.00185566411064 0.000294122787889 0)
(-0.00181316890335 0.000335537580863 0)
(-0.00176460246418 0.000381064165109 0)
(-0.00170924085478 0.000432263342837 0)
(-0.00164562427762 0.000491622215017 0)
(-0.00157100471093 0.000562821789662 0)
(-0.00148118964045 0.000649988932679 0)
(-0.00137145238492 0.000755227853317 0)
(-0.00123954925224 0.000874856046334 0)
(-0.00108932728642 0.000997756990409 0)
(-0.000926659901179 0.00111164842934 0)
(-0.000754339180844 0.00120168421834 0)
(-0.000580011759762 0.0012433387801 0)
(-0.000419062073087 0.0012342685034 0)
(-0.000280534736171 0.00118620576354 0)
(-0.000176965906981 0.00110968738541 0)
(-6.38748856847e-05 0.000976589649722 0)
(8.23655151741e-05 0.000731280197863 0)
(0.000195745433952 0.000652922538066 0)
(0.000276145969443 0.00055840242068 0)
(0.000321113387507 0.000405535592505 0)
(0.000307490816451 0.00023206756715 0)
(0.000267237781202 0.000118640105563 0)
(0.000225566402583 6.4979306109e-05 0)
(0.000202095207398 4.11428356628e-05 0)
(0.000202150277637 5.18174917971e-06 0)
(0.00020066878619 -6.03112471215e-05 0)
(0.000177710101738 -0.000131324983414 0)
(0.000129655454055 -0.000179346839335 0)
(7.4674680233e-05 -0.000217596970464 0)
(2.38714488843e-05 -0.000239689656973 0)
(-6.59654324316e-05 -0.000959268038695 0)
(-0.000196765979648 -0.00109360783213 0)
(-0.000232835845988 -0.00100723522285 0)
(-0.000216685007944 -0.000758693406401 0)
(-0.000402401277408 -0.00098779130252 0)
(-0.000477156571762 -0.00100072605841 0)
(-0.00053673446878 -0.000991603133462 0)
(-0.000627810481368 -0.000945472338431 0)
(-0.000609641607029 -0.000759376073755 0)
(-0.000763877523891 -0.000736012214549 0)
(-0.00072156048082 -0.000521933611744 0)
(-0.000849421017526 -0.000505998081448 0)
(-0.00092922428565 -0.000514546961113 0)
(-0.00109700710571 -0.00059855341994 0)
(-0.00119540353462 -0.000619687558306 0)
(-0.00120687248524 -0.000542726371602 0)
(-0.00127992192967 -0.000507195629755 0)
(-0.00137104710593 -0.000519465941234 0)
(-0.00143796716282 -0.000521410034904 0)
(-0.00149262759908 -0.000503197019326 0)
(-0.00155117830926 -0.000475145319049 0)
(-0.00159947313123 -0.000438495798068 0)
(-0.00165124346134 -0.000400446731257 0)
(-0.00167276853503 -0.000365800544261 0)
(-0.00166874925048 -0.000327803291173 0)
(-0.00177229324759 -0.000293124958746 0)
(-0.00175449845865 -0.000260372293783 0)
(-0.00177368526457 -0.000235144215889 0)
(-0.00180840134592 -0.000215105635376 0)
(-0.00183186710059 -0.000205042508417 0)
(-0.00189348410096 -0.000190189205744 0)
(-0.00191209680397 -0.00018230090985 0)
(-0.00196146831216 -0.000181853658978 0)
(-0.00197777468414 -0.000173682064737 0)
(-0.00199047699978 -0.00015294169518 0)
(-0.0020031664929 -0.000126908878343 0)
(-0.0020135422002 -0.000100353720014 0)
(-0.00202108472353 -7.40507246152e-05 0)
(-0.00202623516114 -4.71035902617e-05 0)
(-0.00202918705018 -1.8554953565e-05 0)
(-0.00202973762442 1.17912224629e-05 0)
(-0.00202749208348 4.33530681042e-05 0)
(-0.00202198240066 7.54218156345e-05 0)
(-0.00201281306934 0.000107779121939 0)
(-0.00199970980042 0.000140777676668 0)
(-0.00198235636876 0.000175051873447 0)
(-0.00196027954185 0.000211210872201 0)
(-0.00193298183374 0.000249669528192 0)
(-0.00190008673508 0.000290669345224 0)
(-0.00186132532302 0.000334508704017 0)
(-0.00181644322349 0.000381864079921 0)
(-0.00176508852186 0.000434081575916 0)
(-0.00170651597507 0.000493450544101 0)
(-0.00163905605557 0.000563429362796 0)
(-0.00155979424449 0.000648440477965 0)
(-0.00146492553002 0.000752598604437 0)
(-0.00135055155454 0.000878036768206 0)
(-0.00121454729537 0.00102143157317 0)
(-0.00105956975246 0.00116383216612 0)
(-0.000891950371084 0.00128710235553 0)
(-0.000710419637947 0.00138573706289 0)
(-0.000517790627312 0.00142376150586 0)
(-0.000331722599749 0.0014003287842 0)
(-0.000165692946385 0.00132680669563 0)
(-3.47651224444e-05 0.00121152540757 0)
(5.82498682237e-05 0.00108706722062 0)
(0.000151307768902 0.000956394785056 0)
(0.000232226261213 0.000687635156416 0)
(0.000357503326319 0.000618109794183 0)
(0.000434365390429 0.000433778997527 0)
(0.000420139972843 0.000185244253062 0)
(0.000332561200204 4.39882606781e-05 0)
(0.000237584953242 9.10238789267e-06 0)
(0.000200482951857 3.57901840849e-05 0)
(0.000229820862887 3.06028227463e-05 0)
(0.000261611310671 -6.23148364345e-05 0)
(0.000229783957276 -0.000182732286732 0)
(0.000159869960584 -0.000242068661336 0)
(8.70418750271e-05 -0.000279494822901 0)
(2.50380979673e-05 -0.000284090696007 0)
(-6.22418691797e-05 -0.0010922312409 0)
(-0.000186970486685 -0.00117296731987 0)
(-0.000201580100134 -0.000935132866808 0)
(-0.000252491615109 -0.000876356343738 0)
(-0.000408569961735 -0.00111428756331 0)
(-0.000430414646496 -0.00106856404719 0)
(-0.000514296633413 -0.00106662246687 0)
(-0.000565299692653 -0.00098825351099 0)
(-0.000633474675458 -0.000886159130404 0)
(-0.000663476873058 -0.000720100349473 0)
(-0.000721707384902 -0.000613627126498 0)
(-0.000837458031842 -0.000609524913803 0)
(-0.000916247386618 -0.000623736472242 0)
(-0.00109011739492 -0.000713478552714 0)
(-0.00118312320721 -0.000694462986112 0)
(-0.00117822207793 -0.000597732243035 0)
(-0.00126790686467 -0.000583234849852 0)
(-0.00135620444702 -0.000593796951859 0)
(-0.00142141800734 -0.000584421461073 0)
(-0.00147595783197 -0.000560650822735 0)
(-0.00153034455893 -0.000530628528942 0)
(-0.00158925939736 -0.000494624403808 0)
(-0.00165316798138 -0.000440775867783 0)
(-0.00169731217618 -0.000389837965619 0)
(-0.0016745508286 -0.000358537557229 0)
(-0.00170383681712 -0.000318811835824 0)
(-0.00178825044633 -0.000289355294533 0)
(-0.00177536585334 -0.000268711984823 0)
(-0.00186257653832 -0.000250543418435 0)
(-0.00183901549785 -0.000230661988404 0)
(-0.00186255179379 -0.000222135975593 0)
(-0.00191936067886 -0.000220468287857 0)
(-0.00196749217394 -0.000214904886172 0)
(-0.00198532520177 -0.000192813637739 0)
(-0.0019989588743 -0.000166552238189 0)
(-0.00201218949416 -0.000138669197038 0)
(-0.00202322747507 -0.00010993490057 0)
(-0.00203145259935 -8.09219833662e-05 0)
(-0.00203704319844 -5.13133663218e-05 0)
(-0.00204000600969 -2.03973388244e-05 0)
(-0.00204049043073 1.23278985067e-05 0)
(-0.00203840789821 4.67415685887e-05 0)
(-0.00203317799082 8.22679403511e-05 0)
(-0.00202427837439 0.000118563409326 0)
(-0.00201139104268 0.000155895521243 0)
(-0.0019940776477 0.000194923950375 0)
(-0.00197165946137 0.000236291853278 0)
(-0.00194347084794 0.000280367039392 0)
(-0.00190905758667 0.000327283738345 0)
(-0.00186813606993 0.000377273937381 0)
(-0.00182050209786 0.000431119991038 0)
(-0.00176591360324 0.000490594732342 0)
(-0.00170367450879 0.000558723611772 0)
(-0.00163213419814 0.00063953719596 0)
(-0.00154890354464 0.000737175676524 0)
(-0.00145241826589 0.000855121459634 0)
(-0.00134088727508 0.00100124420487 0)
(-0.00120415766004 0.00117942491414 0)
(-0.00104024977616 0.00133792212099 0)
(-0.000873616033032 0.00145553323431 0)
(-0.000685184274478 0.00158962140719 0)
(-0.00046000201602 0.00164444612605 0)
(-0.000228135377026 0.00161755674306 0)
(-1.48272017432e-05 0.00152148037889 0)
(0.000160450632794 0.00136729154149 0)
(0.000276046637984 0.00116784386024 0)
(0.000250500048758 0.000921027605213 0)
(0.000258887152666 0.000966901187055 0)
(0.000410972889603 0.000802439508323 0)
(0.00059343086866 0.00049369456865 0)
(0.00058785657709 7.94784358814e-05 0)
(0.000389196824993 -0.00011170933379 0)
(0.000194347061299 -9.2088064185e-05 0)
(0.000142901873804 5.92118557044e-05 0)
(0.000255669761524 0.000130404023788 0)
(0.00036491320779 -3.97006367201e-05 0)
(0.00030697260549 -0.000280456087145 0)
(0.000189687192528 -0.000320850709604 0)
(9.81410934466e-05 -0.000360680228159 0)
(2.34398018758e-05 -0.000335430130806 0)
(-4.81974033794e-05 -0.00120220602339 0)
(-0.000140945900421 -0.00124335660318 0)
(-0.0001886110534 -0.000987269604283 0)
(-0.000292646157602 -0.000987835031143 0)
(-0.000358931000497 -0.00108001783459 0)
(-0.000396695898398 -0.00113336279522 0)
(-0.000501423921124 -0.00114548826611 0)
(-0.00052180212868 -0.00101968603245 0)
(-0.000642052244637 -0.00100841831594 0)
(-0.000646010301462 -0.000774798010289 0)
(-0.000728883741171 -0.000704005675567 0)
(-0.000828251814223 -0.00070981873587 0)
(-0.000913512020452 -0.000737551264201 0)
(-0.00106583186428 -0.00081913591924 0)
(-0.00115144523628 -0.000769416579807 0)
(-0.00115309136352 -0.000658128216722 0)
(-0.00125594624707 -0.000661856593682 0)
(-0.00133740459447 -0.000667779411355 0)
(-0.0014022972491 -0.000647744868419 0)
(-0.00146140709324 -0.000618331128405 0)
(-0.00151262243601 -0.000587236528606 0)
(-0.00157243906836 -0.000554968224034 0)
(-0.00160225511673 -0.000488013024889 0)
(-0.00170712900797 -0.000422675506732 0)
(-0.00170500313321 -0.000379088724112 0)
(-0.00169956733633 -0.000359147215077 0)
(-0.00180740369852 -0.000330548980883 0)
(-0.00177747900593 -0.000295358916802 0)
(-0.00180570468121 -0.000278252427344 0)
(-0.0018796676031 -0.000263623271492 0)
(-0.001898177444 -0.000259189965524 0)
(-0.00194965731295 -0.000259966835511 0)
(-0.00196945310318 -0.000242943389977 0)
(-0.0019905756295 -0.000212803695221 0)
(-0.0020076068189 -0.000181775932678 0)
(-0.00202174128302 -0.000151129515707 0)
(-0.00203349878073 -0.000120038278851 0)
(-0.00204246679396 -8.84269891058e-05 0)
(-0.00204890258289 -5.60014458235e-05 0)
(-0.0020522890005 -2.23804845327e-05 0)
(-0.00205259152993 1.28384723089e-05 0)
(-0.00205038911053 4.9985770979e-05 0)
(-0.00204547239009 8.88701748827e-05 0)
(-0.00203701150109 0.000129098624055 0)
(-0.00202447327905 0.000170836191352 0)
(-0.00200733749284 0.000214845854087 0)
(-0.00198474796893 0.000261883958879 0)
(-0.00195582041395 0.000312241199547 0)
(-0.00191994164812 0.0003658291476 0)
(-0.00187678574485 0.000422703170273 0)
(-0.00182624942484 0.000483705192504 0)
(-0.00176820873675 0.000551029592265 0)
(-0.00170195452395 0.00062824732447 0)
(-0.00162599622992 0.000719097603159 0)
(-0.00153940866642 0.000825707973744 0)
(-0.00144790955346 0.000950623752618 0)
(-0.0013513641582 0.0011215512281 0)
(-0.00120706290349 0.00136469133596 0)
(-0.00102793748807 0.00152765748112 0)
(-0.000895547241164 0.00164271413452 0)
(-0.000698953263173 0.00186946118284 0)
(-0.000414037415849 0.00192578172008 0)
(-0.000116798266772 0.00184840174355 0)
(0.000155331074147 0.00168015274952 0)
(0.000386761166338 0.00143160256102 0)
(0.000579539828757 0.00110417887468 0)
(0.000411959763833 0.000478888633555 0)
(0.000104185871946 0.000546290610176 0)
(0.000575016063472 0.0006099133196 0)
(0.000976410806362 0.000711502418596 0)
(0.00086556484586 -0.000249938897956 0)
(0.000416113860562 -0.000499123787794 0)
(3.25865298631e-05 -0.000340343745306 0)
(-3.97005665842e-05 9.08997403977e-05 0)
(0.000278834321503 0.000370035962837 0)
(0.000590273831112 3.8201416377e-05 0)
(0.000435114150237 -0.000478415694129 0)
(0.000203211492327 -0.000406857873389 0)
(9.31400225954e-05 -0.000483217141053 0)
(4.72430786611e-06 -0.000380905727854 0)
(-3.64131570404e-05 -0.00128099345652 0)
(-9.59056474961e-05 -0.00130312513605 0)
(-0.000181172716797 -0.00107498599999 0)
(-0.000299579615642 -0.00107788536692 0)
(-0.00033117493282 -0.00108420460294 0)
(-0.000400599652334 -0.00121141692943 0)
(-0.000497512281502 -0.00121965352664 0)
(-0.000472841473946 -0.000992706718393 0)
(-0.000644069981615 -0.00110857416279 0)
(-0.000626516811341 -0.00082539435474 0)
(-0.000726642597267 -0.000785480533844 0)
(-0.000816677214646 -0.000802638370983 0)
(-0.000902370730403 -0.000841734508201 0)
(-0.00104222423427 -0.000910313896891 0)
(-0.00103828016262 -0.000785300450626 0)
(-0.00110906647326 -0.000725280239161 0)
(-0.00123364090776 -0.000750380819655 0)
(-0.00131259864541 -0.000743717654529 0)
(-0.00137958296132 -0.000712768211903 0)
(-0.00144325657114 -0.00067666186835 0)
(-0.00149984937492 -0.000642618499222 0)
(-0.00156685579823 -0.000611417757924 0)
(-0.00156293032398 -0.000536140029104 0)
(-0.00161901668749 -0.000455916859032 0)
(-0.00173695763689 -0.000419169329666 0)
(-0.00170370863715 -0.00039092624905 0)
(-0.00174243202177 -0.000351163522517 0)
(-0.00180648699524 -0.000322579508126 0)
(-0.00180955155057 -0.000315395645349 0)
(-0.00184211327364 -0.000302168130451 0)
(-0.00188934215071 -0.000298207040198 0)
(-0.00195508915312 -0.000295315340659 0)
(-0.00197667907102 -0.000267403696901 0)
(-0.00199741562506 -0.00023314215634 0)
(-0.00201646021335 -0.000198708344498 -8.39306725527e-29)
(-0.00203197319094 -0.000164853012802 8.16259960619e-29)
(-0.00204483918581 -0.000130857193844 0)
(-0.00205422321959 -9.64970405702e-05 0)
(-0.0020610385123 -6.1369495516e-05 0)
(-0.00206544549709 -2.48472134459e-05 0)
(-0.0020662403305 1.32645149727e-05 0)
(-0.00206383286153 5.32140005992e-05 0)
(-0.00205889998111 9.5252976258e-05 0)
(-0.00205090402722 0.000139267451221 0)
(-0.00203893731259 0.000185408668202 0)
(-0.00202223205109 0.000234568788887 0)
(-0.00199978867354 0.000287720640697 0)
(-0.00197048467508 0.000345087307307 0)
(-0.00193346703902 0.000406215730284 0)
(-0.00188835846808 0.000470817651064 0)
(-0.00183521452019 0.000539680898782 0)
(-0.00177396027002 0.000615409485548 0)
(-0.00170355673369 0.000701905315167 0)
(-0.00162229354494 0.000801700306294 0)
(-0.00153146290608 0.000912756287854 0)
(-0.00145565567301 0.0010333976036 0)
(-0.00139388618773 0.00124509163355 0)
(-0.00121480442337 0.00159731311205 0)
(-0.00105525318374 0.00155054314407 0)
(-0.00106216985158 0.0010065384582 0)
(-0.000798694087402 0.000889352409483 0)
(-0.000191742650695 0.00090611638269 0)
(0.000395063516933 0.00090638919797 0)
(0.000999183426595 0.0008560360996 0)
(0.00173307376436 0.000806899838296 0)
(0.00304206696016 0.0007777541545 0)
(0.00353874822994 0.000745226648408 0)
(0.0136136776822 0.00191318260517 0)
(0.0133435482179 -0.00147991270444 0)
(0.00226178198854 -0.000378409247535 0)
(0.00195842745532 -0.000316120102594 0)
(0.000538916779301 -0.000208761157707 0)
(-0.000331689185376 0.000129878287532 0)
(-0.00040683638257 0.000906073692962 0)
(0.000547156784586 0.00138314451576 0)
(0.00117489736929 0.000433901164355 0)
(0.000659200196867 -0.00142089119598 0)
(0.00016719313553 -0.000540244549613 0)
(5.97151718687e-05 -0.000681808022466 0)
(-6.5735075067e-05 -0.000347260794559 0)
(-3.94304608301e-05 -0.00135764011379 0)
(-0.000111076039831 -0.00136519924474 0)
(-0.000197530158249 -0.00134831128915 0)
(-0.000252858843953 -0.00115367352073 0)
(-0.000320338068163 -0.0011622829809 0)
(-0.000410563517134 -0.00129236882777 0)
(-0.000493700418107 -0.00128745291506 0)
(-0.000486992436619 -0.00106530588604 0)
(-0.000659974597422 -0.00119123272895 0)
(-0.000614463592525 -0.000883371232643 0)
(-0.000724454444615 -0.000867140146032 0)
(-0.00080862907014 -0.000889928582762 0)
(-0.000892654480089 -0.00093319200118 0)
(-0.00102859223111 -0.00099062241898 0)
(-0.00100410769584 -0.000839133742628 0)
(-0.001102779627 -0.000815653553855 0)
(-0.0012146969587 -0.000839261017495 0)
(-0.00128925262519 -0.000819715769237 0)
(-0.00135750935059 -0.000780145454128 0)
(-0.00142113017726 -0.000736942405214 0)
(-0.00148435463936 -0.00069833750846 0)
(-0.00156250329939 -0.000659882699917 0)
(-0.00155058018835 -0.000579687387944 0)
(-0.00159971608157 -0.000519988886358 0)
(-0.00174211556001 -0.000470398044831 0)
(-0.00171398703112 -0.000414847056787 0)
(-0.00173513667823 -0.000396151448371 0)
(-0.0018438614165 -0.00036713025898 0)
(-0.001832297062 -0.000335522188883 0)
(-0.00186166299205 -0.000342343259472 0)
(-0.00193176913846 -0.000350735408222 0)
(-0.00195485911701 -0.000329513377717 0)
(-0.00198094127487 -0.000292568419998 0)
(-0.00200479901501 -0.000254497030651 0)
(-0.0020258288829 -0.000216963229412 0)
(-0.00204222862757 -0.000179784779779 0)
(-0.00205617363443 -0.000142733974323 0)
(-0.00206738972304 -0.000105305117059 0)
(-0.00207452657985 -6.72461956221e-05 0)
(-0.00207899367924 -2.79374142573e-05 0)
(-0.00208065368722 1.3225339843e-05 0)
(-0.00207871587025 5.63182983404e-05 0)
(-0.00207378351388 0.000101535355973 0)
(-0.00206603587516 0.000149082824232 0)
(-0.00205470685243 0.00019939119899 0)
(-0.00203877395632 0.000253669732632 0)
(-0.00201702241133 0.00031326836886 0)
(-0.0019880402016 0.00037841209251 0)
(-0.00195056342216 0.000448041002682 0)
(-0.00190422418831 0.000521154467882 0)
(-0.00184955594934 0.000598412898789 0)
(-0.00178622217795 0.000682884984565 0)
(-0.001712333707 0.000778827151158 0)
(-0.00162466022927 0.000887078383373 0)
(-0.00152665395947 0.000999237626802 0)
(-0.00149408340041 0.00107063670321 0)
(-0.00152781378946 0.00107875016734 0)
(-0.0012920933342 0.000863190942995 0)
(-0.000167374138017 0.000807405510853 0)
(0.00186765406333 0.00205927387113 0)
(0.0159666427465 0.00665551452854 0)
(0.0257414836716 0.00647383792981 0)
(0.0365308247331 0.00606330711958 0)
(0.0473809686817 0.00569487579189 0)
(0.0574595861462 0.00544378240418 0)
(0.0663253810741 0.00542167547005 0)
(0.0730615880088 0.00643759031829 0)
(0.0774253216721 0.00511445113705 0)
(0.0804781930036 0.00122097788649 0)
(0.0832511244184 -0.00460628477564 0)
(0.0850943054497 -0.00538177990395 0)
(0.0826998767135 -0.00543263960975 0)
(0.0755745645454 -0.00597404684656 0)
(0.0667119517955 -0.00787222921418 0)
(0.0428348619931 -0.00841219963264 0)
(0.00526698009269 -0.00126021981733 0)
(0.00142622516027 0.000213308412219 0)
(-0.000417697836656 0.000672632138108 0)
(-8.91844628091e-05 -0.00137067200744 0)
(-0.00028128712147 -0.000159539722954 0)
(-4.20397380117e-05 -0.00143552312627 0)
(-0.000136841819673 -0.00143293209039 0)
(-0.000157575932484 -0.00122164945992 0)
(-0.000203684417939 -0.00123226104999 0)
(-0.000300099800688 -0.00124593521021 0)
(-0.000409838839538 -0.00137266080411 0)
(-0.000489483919024 -0.00134653876696 0)
(-0.000512762885566 -0.00114641923876 0)
(-0.000666030757296 -0.00126168058636 0)
(-0.00060445178842 -0.000949420568827 0)
(-0.00072209507078 -0.000952066072556 0)
(-0.000805007285385 -0.000976267770916 0)
(-0.000891695172226 -0.00102079224403 0)
(-0.00101967853729 -0.00106235727938 0)
(-0.00100681262389 -0.000907481324737 0)
(-0.0011112735275 -0.000902164697829 0)
(-0.00120593555877 -0.00091987763375 0)
(-0.00127418422249 -0.000892772435882 0)
(-0.00134089230807 -0.000848127926293 0)
(-0.00140503363723 -0.000800771104103 0)
(-0.00146806299487 -0.000756338257531 0)
(-0.00154997986226 -0.000710803460483 0)
(-0.0015733009586 -0.000637413490079 0)
(-0.00159102692108 -0.000572664848284 0)
(-0.00165925733447 -0.000499071744887 0)
(-0.00175378970317 -0.000457896214737 0)
(-0.00173440779783 -0.000437258925279 0)
(-0.00176851054792 -0.000405984530586 0)
(-0.00188788502903 -0.000390141824825 0)
(-0.00191901367881 -0.000387611251546 0)
(-0.00194250265801 -0.000381290496681 0)
(-0.00196548801304 -0.000354486981391 0)
(-0.00199012768355 -0.000317624023522 0)
(-0.00201423369202 -0.000277141695129 0)
(-0.00203541174514 -0.00023621964978 0)
(-0.00205355535201 -0.000195911451639 -8.03186858725e-29)
(-0.00206834635143 -0.000155786762789 7.81297990933e-29)
(-0.00208014484677 -0.000115168047166 0)
(-0.00208914249188 -7.3812288241e-05 0)
(-0.00209399522183 -3.14729185907e-05 0)
(-0.00209579907652 1.26239438845e-05 0)
(-0.00209452870545 5.89801767424e-05 0)
(-0.00209006188978 0.000107642071012 0)
(-0.00208258885602 0.000158638869351 0)
(-0.00207176322309 0.000212598750029 0)
(-0.00205693020123 0.000271537442558 0)
(-0.00203668659056 0.000337768285394 0)
(-0.00200890041819 0.000411479439548 0)
(-0.00197201330783 0.000490399330715 0)
(-0.00192601074044 0.000572581806679 0)
(-0.00187163482581 0.000658334939567 0)
(-0.00180856220711 0.000751230833351 0)
(-0.00173336314011 0.00085759944424 0)
(-0.00163998093214 0.000986985193332 0)
(-0.0015144907444 0.00113687010087 0)
(-0.00139098041188 0.000786084215714 0)
(-0.00110012790259 0.000591500940281 1.10266987685e-28)
(0.0045477170933 0.00453139623101 -2.39784487449e-27)
(0.016874625044 0.00860190676475 0)
(0.0285661552345 0.015059431285 0)
(0.039399658708 0.0184974192605 0)
(0.0496332247627 0.019552928317 0)
(0.0602126135641 0.019435796364 0)
(0.0707946592686 0.0186755200683 0)
(0.0808078566156 0.0174054572665 0)
(0.0898512037619 0.0156422607159 0)
(0.0975175314589 0.013322386708 0)
(0.103609737249 0.00985716438122 0)
(0.10865578417 0.00502726712389 0)
(0.112564665377 0.000490934936761 0)
(0.114523921945 -0.00333072456369 0)
(0.113801898196 -0.00774073015659 0)
(0.109686119229 -0.0136118587069 0)
(0.103402690835 -0.0218566417359 0)
(0.094665947112 -0.0307405823063 0)
(0.0791463810188 -0.0342865319411 0)
(0.0647638674959 -0.0275101142804 0)
(0.00646316071075 -0.00246904473028 0)
(0.000883680841182 0.000343600159157 0)
(-0.00126004840662 0.00141039088018 0)
(-3.89754932454e-05 -0.00151675922319 0)
(-0.000127198593141 -0.00151107857835 0)
(-0.0001479280236 -0.00126969719952 0)
(-0.000196039499259 -0.00132173429953 -1.78301790615e-29)
(-0.000296698505454 -0.00135744727379 1.82694530149e-29)
(-0.000404967450249 -0.00144919173383 0)
(-0.000470985584449 -0.00140249490962 0)
(-0.000527763859801 -0.00123758834568 0)
(-0.000603591283098 -0.00119414399974 0)
(-0.00060670312068 -0.00102552668365 0)
(-0.000719316142409 -0.00104314820751 0)
(-0.000803948218267 -0.00106474500559 0)
(-0.000897878085776 -0.00111092066632 0)
(-0.001015113225 -0.00113165739025 0)
(-0.00100870754152 -0.00097781342053 0)
(-0.00111829037396 -0.00098434276156 0)
(-0.0012006601141 -0.00099316965387 0)
(-0.00126554714996 -0.000961521621653 0)
(-0.001330282899 -0.000915126539495 0)
(-0.00139403534136 -0.000865361489195 0)
(-0.00145620655306 -0.000816933252261 0)
(-0.00153080806611 -0.00076557973498 0)
(-0.00158928879786 -0.000695933989501 0)
(-0.00159696355812 -0.000617923658691 0)
(-0.00163770071601 -0.000554453594208 0)
(-0.00179206370961 -0.000514518750519 0)
(-0.00175746514844 -0.000463564208382 0)
(-0.00177398797339 -0.000455582058909 0)
(-0.00182214231289 -0.000439134387147 0)
(-0.00190687104019 -0.000430191229371 0)
(-0.00194549850995 -0.000413597279919 0)
(-0.00197334354968 -0.000381302181072 0)
(-0.00199925242565 -0.000342171297036 0)
(-0.00202337633642 -0.000299871009854 0)
(-0.0020472516603 -0.000256596840296 0)
(-0.00206586535299 -0.000212992844438 0)
(-0.00208183447228 -0.000169726838016 0)
(-0.00209418945759 -0.00012599149356 0)
(-0.0021039445365 -8.13618538544e-05 0)
(-0.00211005635305 -3.56153316793e-05 0)
(-0.00211219663334 1.15748475499e-05 0)
(-0.0021112267248 6.10247291094e-05 0)
(-0.00210756273297 0.000113266818206 0)
(-0.00210083694593 0.000167992611766 0)
(-0.00209044122394 0.000225256676248 0)
(-0.00207619631067 0.000287806229208 0)
(-0.00205773040333 0.000359884308118 0)
(-0.00203279394282 0.000442389175794 0)
(-0.00199927086476 0.000531726504942 0)
(-0.00195528151373 0.000623837055343 0)
(-0.0019023765512 0.00071672047815 0)
(-0.00184405616499 0.000814426260403 0)
(-0.00177972507076 0.000927174097542 0)
(-0.0017200442679 0.00102150745835 0)
(-0.00136102695676 0.000579560253386 0)
(-0.000729867746178 0.000683221724102 0)
(0.0113182504062 0.0094576334861 0)
(0.0239962005171 0.0170771169089 0)
(0.0366600895157 0.0225283292786 0)
(0.0490511235905 0.0264799091986 0)
(0.0607627583309 0.0290890333315 0)
(0.0718895989726 0.029982623032 0)
(0.0827856590278 0.0295666889743 0)
(0.0933713825243 0.0282244891475 0)
(0.1033480434 0.0261165088717 0)
(0.112435685814 0.0232871100181 0)
(0.120395141369 0.0197088916866 0)
(0.127092075627 0.0152142962127 0)
(0.132586268756 0.00972404961736 0)
(0.136884369998 0.00364652269182 0)
(0.139286397508 -0.00291323122364 0)
(0.139645171219 -0.010209379351 0)
(0.137423512132 -0.0187040320411 0)
(0.132775421625 -0.0286606552493 0)
(0.12580723269 -0.0386086225269 0)
(0.114407990455 -0.0456861264714 0)
(0.100315482013 -0.0501081427499 0)
(0.0748176017386 -0.0496101519054 0)
(0.0458928287721 -0.0280073540245 0)
(0.000218935394804 0.000922626345076 0)
(-3.58222156322e-05 -0.00159371447482 0)
(-0.000124596091047 -0.00158858141607 0)
(-0.000138929564493 -0.00126143196671 0)
(-0.000195603334283 -0.0014118967136 0)
(-0.000303425105834 -0.00148084257963 0)
(-0.000400073808909 -0.00152098079868 0)
(-0.000453802588834 -0.00146096110442 0)
(-0.000530390848885 -0.00134009309893 0)
(-0.000600630137958 -0.00123252844934 0)
(-0.000624818336465 -0.00109740560107 0)
(-0.000725488132357 -0.00113156756171 0)
(-0.000805774504147 -0.00115405465194 0)
(-0.000905660515464 -0.00120197444917 0)
(-0.0010074198896 -0.00119826645854 0)
(-0.00100300940397 -0.00104922900676 0)
(-0.00111720448276 -0.00106591552354 0)
(-0.0011931391675 -0.00106434003585 0)
(-0.00125856445251 -0.00102806760757 0)
(-0.0013224143776 -0.00098073976474 0)
(-0.00138533736736 -0.000929212964266 0)
(-0.00144750530816 -0.000878406351246 0)
(-0.00151717878317 -0.000825431437166 0)
(-0.00158823253133 -0.00075597555014 0)
(-0.00160202976801 -0.000667810214429 0)
(-0.00163089533744 -0.000607180167526 0)
(-0.00171168372258 -0.000545057937228 0)
(-0.00179669927303 -0.000502329120461 0)
(-0.00179953751228 -0.000488118293922 0)
(-0.00183851685672 -0.000489154267081 0)
(-0.00191664004773 -0.00048670594432 0)
(-0.00194181419656 -0.000452012809634 0)
(-0.00197448417116 -0.000410995922072 0)
(-0.00200243327225 -0.000368156951112 0)
(-0.00203095347803 -0.000324650328594 0)
(-0.00205628012264 -0.000278698403898 0)
(-0.00207879472553 -0.000231590798754 0)
(-0.00209538271122 -0.000184622382202 7.66514703761e-29)
(-0.00210933557769 -0.000137735913254 -7.45123302233e-29)
(-0.00211974881253 -8.97476404841e-05 0)
(-0.00212679687421 -4.06261247652e-05 0)
(-0.00213003508782 9.84721671272e-06 0)
(-0.00212949272843 6.26102701409e-05 0)
(-0.00212563908309 0.000118541220255 0)
(-0.00211962440581 0.00017721649544 0)
(-0.00210969281833 0.000237067529969 0)
(-0.00209616576371 0.000301399681203 0)
(-0.00208057026827 0.000379048852252 0)
(-0.0020608934985 0.000472004153147 0)
(-0.0020324592937 0.000572025465547 0)
(-0.00199073893571 0.000675006369613 0)
(-0.00193851995017 0.00077281169968 0)
(-0.00188467585721 0.000874138720571 0)
(-0.00178400241593 0.000911723682876 0)
(-0.00137270400217 0.000428614632967 0)
(-0.000964125392505 0.00279877203291 0)
(0.0162752731295 0.0150172672774 0)
(0.0297687423224 0.0236377555885 0)
(0.043257797504 0.0302760035406 0)
(0.0564474840489 0.035234112408 0)
(0.0691973657459 0.0386890805576 0)
(0.0814071772182 0.0407525311783 0)
(0.0930883495844 0.0413263970984 0)
(0.104332321474 0.0405757604178 0)
(0.11510474667 0.0387269228914 0)
(0.125251356796 0.0359106682489 0)
(0.13459437125 0.0321712135439 0)
(0.142973390171 0.0274938256387 0)
(0.150265736695 0.0218126964096 0)
(0.15638512562 0.0150925623804 0)
(0.161242138137 0.007424403738 0)
(0.164273654766 -0.00111819045295 0)
(0.165534557406 -0.0106132411301 0)
(0.164539088748 -0.0214056317507 0)
(0.1610061041 -0.0335664872896 0)
(0.15469032372 -0.0464770417211 0)
(0.14426988772 -0.0587962038263 0)
(0.128524388153 -0.0697585225189 0)
(0.102605464932 -0.0753952846746 0)
(0.0650639823115 -0.0700920438027 0)
(0.0195122396446 -0.0671259649047 0)
(-3.08447392048e-05 -0.00166412694903 0)
(-0.000107044320794 -0.00166094686885 0)
(-0.000127599464347 -0.00125302026912 0)
(-0.00021469644042 -0.00149629440309 0)
(-0.000319070328292 -0.001581940685 0)
(-0.000402441368144 -0.00158830275023 0)
(-0.000445598016295 -0.00150688414792 0)
(-0.000548478842867 -0.00147227147183 0)
(-0.000598290419266 -0.00127130733289 0)
(-0.000638666132108 -0.00116476545807 0)
(-0.00073122856815 -0.00121460620109 0)
(-0.000804423734144 -0.00124147728765 0)
(-0.000909219791209 -0.00128896552317 0)
(-0.000966663919611 -0.0012293919887 0)
(-0.000996018969629 -0.00112728394182 -1.28336634601e-28)
(-0.00110559790153 -0.00114783009173 1.33809156294e-28)
(-0.00117988788917 -0.00113542713304 0)
(-0.00124649682862 -0.00109386254351 0)
(-0.00131365744292 -0.0010467786279 0)
(-0.00137619778979 -0.000992974075884 0)
(-0.00143898740531 -0.000939915967758 0)
(-0.00150535377304 -0.00088572575114 0)
(-0.00158079667323 -0.0008156037562 0)
(-0.00160152881312 -0.000717214589371 0)
(-0.00163608704041 -0.00065540046712 0)
(-0.00168299823506 -0.000606305663882 0)
(-0.00183587131222 -0.000580321825934 0)
(-0.00185122600351 -0.000540387786483 0)
(-0.00189627720008 -0.00053681679143 0)
(-0.001925360767 -0.000521057085714 0)
(-0.001949984991 -0.000485894149558 0)
(-0.00197713827116 -0.0004420803356 0)
(-0.00200775288083 -0.000396878945895 0)
(-0.0020374927042 -0.000352273040392 0)
(-0.00206536820446 -0.000303039986847 0)
(-0.00208727097879 -0.000251555540367 0)
(-0.00210860381847 -0.000201633955989 0)
(-0.00212418357931 -0.000151138905142 0)
(-0.00213638381887 -9.94016508639e-05 0)
(-0.00214516079104 -4.64187078253e-05 0)
(-0.00214843064025 7.65530738432e-06 0)
(-0.0021481988373 6.35540372472e-05 6.73035469049e-29)
(-0.00214501658609 0.000122694934753 -6.55162332601e-29)
(-0.00214097906388 0.000186016561587 0)
(-0.00213274008701 0.000252362761324 0)
(-0.00210915438476 0.000320634003509 0)
(-0.00207630070925 0.00039576295646 0)
(-0.00205920877632 0.000486313991855 0)
(-0.00205930629304 0.000599494137083 0)
(-0.00202645834499 0.000724837738635 0)
(-0.00198052879016 0.000829704895611 0)
(-0.00186333002752 0.000871256682306 0)
(-0.0014992555269 0.000358456784541 0)
(0.00170444779479 0.00402746385435 0)
(0.0195077530296 0.0188476769989 0)
(0.0341761486539 0.0293603420577 0)
(0.0483160588845 0.0375014455911 0)
(0.0622085374685 0.0437708692892 0)
(0.0757405811226 0.0483609341899 0)
(0.0888197943795 0.0513732848836 0)
(0.101392382529 0.0528977907637 0)
(0.113443882028 0.0529815646262 0)
(0.124988996422 0.0517333458592 0)
(0.136003824992 0.0492921376308 0)
(0.146405819542 0.0457558354568 0)
(0.1560859644 0.0411650964907 0)
(0.164934331985 0.0355139747622 0)
(0.172848451888 0.028762386171 0)
(0.179725968951 0.020864968992 0)
(0.185425519197 0.0117906085148 0)
(0.189761273421 0.00154181126716 0)
(0.192171211823 -0.0100119417992 0)
(0.192602515155 -0.023139323429 0)
(0.190517795983 -0.0380182686764 0)
(0.185295232609 -0.0545574587434 0)
(0.175553814495 -0.0723190588362 0)
(0.159120809261 -0.0910657842804 0)
(0.131326487896 -0.10982194421 0)
(0.0901794051821 -0.128452433572 0)
(0.00337652738886 -0.0158520094837 0)
(-2.68766683488e-05 -0.00172555972163 0)
(-8.7860015744e-05 -0.00172227914688 0)
(-0.000127516665243 -0.00133244601959 0)
(-0.000244341586537 -0.0016248203314 0)
(-0.000331566157768 -0.00166568951698 0)
(-0.000404880693441 -0.00165509303348 0)
(-0.000443898095632 -0.00155071071879 0)
(-0.000554385605139 -0.00157266767639 0)
(-0.000586890035482 -0.00131783340737 0)
(-0.000641500771048 -0.00122704511655 0)
(-0.00073194970802 -0.00129168540183 0)
(-0.000797948191872 -0.00132306878132 0)
(-0.000906871373198 -0.00137339653095 0)
(-0.000921875869864 -0.00124595427109 0)
(-0.000994397119922 -0.0012050709424 0)
(-0.00109319492607 -0.00122818252881 0)
(-0.0011669641296 -0.00120752812354 0)
(-0.00122412575041 -0.00115192149327 0)
(-0.00130208506738 -0.00111323682473 0)
(-0.00136496744334 -0.00105734322605 0)
(-0.00142970050532 -0.00100195454667 0)
(-0.00149537530318 -0.00094717592325 0)
(-0.00157082943269 -0.000874953909356 0)
(-0.00159754404286 -0.000769603645077 0)
(-0.00164096389717 -0.000706171888823 0)
(-0.00166521928188 -0.000661139324697 0)
(-0.0017490771488 -0.000624643944198 0)
(-0.00180696809987 -0.000583091839343 0)
(-0.00185627035313 -0.000568766592884 0)
(-0.00192182459458 -0.000557400716779 0)
(-0.00195302056568 -0.000518299484515 0)
(-0.00197266329708 -0.000472191332719 0)
(-0.00201376398323 -0.000429557617415 0)
(-0.00204425269856 -0.00038195394998 0)
(-0.00206732313886 -0.000327940361719 0)
(-0.0020978059169 -0.000274336996052 0)
(-0.00212010157116 -0.000221028409913 0)
(-0.00213768872696 -0.000166529954963 7.26726853986e-29)
(-0.0021516225696 -0.000110960415168 -7.05538460534e-29)
(-0.00216251416948 -5.39239576111e-05 0)
(-0.00216933417435 4.33273702275e-06 0)
(-0.00216989021001 6.41064344158e-05 0)
(-0.0021659396362 0.000127912148665 0)
(-0.00215526709592 0.000198782553065 0)
(-0.00213662127219 0.000273735613939 0)
(-0.00210716688983 0.000342870302164 0)
(-0.00208484570266 0.000409708306469 0)
(-0.00208774941426 0.000492757333923 0)
(-0.00208629366474 0.000610922860794 0)
(-0.00205413881722 0.000781776292773 0)
(-0.00196014360031 0.000862547219708 0)
(-0.00150988167769 0.000288051260319 0)
(0.00169527234822 0.00546383275106 0)
(0.0206964204415 0.0219528308438 0)
(0.0364955290307 0.0341010915794 0)
(0.0516121731022 0.0440132308882 0)
(0.0662583842407 0.0517972696288 0)
(0.0805047854582 0.0576831007404 0)
(0.094317597171 0.061829252593 0)
(0.107647643228 0.0643511810482 0)
(0.120465208323 0.065352771772 0)
(0.132761530106 0.0649218331619 0)
(0.144539714929 0.0631531241443 0)
(0.155788540323 0.0601448316611 0)
(0.166468462079 0.0559691840648 0)
(0.17652028874 0.0506569983759 0)
(0.18587675077 0.0441985253016 0)
(0.19446526137 0.0365496034571 0)
(0.202200615481 0.0276417143377 0)
(0.208955880953 0.0173884611595 0)
(0.214641110362 0.00568538120659 0)
(0.218646403578 -0.00769807789228 0)
(0.221051244465 -0.0230035096323 0)
(0.221245508118 -0.0406275129206 0)
(0.21850566177 -0.0609281055768 0)
(0.211582416375 -0.084311261101 0)
(0.198552704917 -0.111552582311 0)
(0.176212556761 -0.143357413232 0)
(0.140956104666 -0.180034551132 0)
(0.0835728275381 -0.176129503317 0)
(-2.58023917458e-05 -0.00178208524418 0)
(-8.186996158e-05 -0.00177716610712 0)
(-0.000135554438899 -0.00142025178041 0)
(-0.000260829140318 -0.00173457840942 0)
(-0.000326540843862 -0.00173443904909 0)
(-0.000393265813692 -0.00172228758644 0)
(-0.000438826176765 -0.00160028903328 0)
(-0.000550935978114 -0.00164860800144 0)
(-0.00057395497015 -0.00137691743547 0)
(-0.000639116402945 -0.00129125457106 0)
(-0.000731495315436 -0.00136647366368 0)
(-0.000794239598734 -0.00139948630907 0)
(-0.000901807757608 -0.00145232991342 0)
(-0.000925940717505 -0.00131749412179 0)
(-0.00100135791617 -0.00128129361654 0)
(-0.00109213852473 -0.00130523851565 0)
(-0.00116150390284 -0.00127979068084 0)
(-0.00121539413251 -0.00121826694254 0)
(-0.00129169138482 -0.0011793214109 0)
(-0.00135385468292 -0.00112120845027 0)
(-0.00141820162913 -0.0010632105663 0)
(-0.00148787230556 -0.00101130537976 0)
(-0.00155833718536 -0.000934606235702 0)
(-0.00159179135221 -0.000824252118606 0)
(-0.00164784156248 -0.000756236792055 0)
(-0.00166877924326 -0.000705392610311 0)
(-0.00173311352151 -0.000678260834071 0)
(-0.00180841307257 -0.000652125174989 0)
(-0.00189288603866 -0.000635857941129 0)
(-0.00191415281792 -0.00059726529418 0)
(-0.00195164974077 -0.000550010539857 0)
(-0.00197374710254 -0.000501341240815 0)
(-0.00200371097523 -0.000457612442633 0)
(-0.00203457514279 -0.000411227340765 0)
(-0.00206655237193 -0.000358994012949 0)
(-0.00210488305209 -0.000301909538421 0)
(-0.00213072567061 -0.000242806083139 0)
(-0.00215025757341 -0.000183639111217 0)
(-0.00216609289237 -0.000124483594994 0)
(-0.00217854616417 -6.39622358512e-05 0)
(-0.00218819143824 -1.00365283259e-06 6.64874321071e-29)
(-0.00219060380828 6.49003253727e-05 -6.43045795237e-29)
(-0.00218396499553 0.000137708578331 0)
(-0.00216265658778 0.000217777197319 0)
(-0.0021441444173 0.000294616448524 0)
(-0.00213703028774 0.000359699990206 0)
(-0.00212632553185 0.000417781199747 0)
(-0.00212988133041 0.000497364763299 0)
(-0.00212520950026 0.000635972331842 0)
(-0.00202764875359 0.000861032269684 0)
(-0.00150859927025 0.000278410965356 0)
(-0.000241259285624 0.00497326286057 0)
(0.0206225140192 0.0242827516186 0)
(0.0371028776564 0.0381580283034 0)
(0.0530518331143 0.0496898188795 0)
(0.0685237238011 0.0590880145346 0)
(0.083500930424 0.0664321151792 0)
(0.0979909782811 0.0718589395003 0)
(0.111983265055 0.0755132829464 0)
(0.125461006575 0.0775237908077 0)
(0.138418449712 0.0780054790376 0)
(0.150862337506 0.0770595251212 0)
(0.162805489658 0.0747777865846 0)
(0.174255057684 0.0712405893425 0)
(0.18520455551 0.0665037128147 0)
(0.195635069396 0.0605878605376 0)
(0.205519495076 0.0534754377979 0)
(0.214822901925 0.0451106793207 0)
(0.22349669651 0.0353994877141 0)
(0.231455373151 0.0242048945813 0)
(0.238674835523 0.0113218849413 0)
(0.244577856856 -0.00354769348468 0)
(0.249475419812 -0.020560832107 0)
(0.252842460104 -0.040418182297 0)
(0.25407617376 -0.0638935083559 0)
(0.252230789391 -0.0920992809801 0)
(0.245580251363 -0.126946639535 0)
(0.230593960988 -0.171568574904 0)
(0.195849986157 -0.232787797504 0)
(0.134205736466 -0.318025485604 0)
(-2.59817474421e-05 -0.00183677837572 0)
(-8.24567547313e-05 -0.00183100957778 0)
(-0.000148714737208 -0.00153378445374 0)
(-0.000268013329779 -0.00181934426378 0)
(-0.000313767857192 -0.00179374180759 0)
(-0.000372354996447 -0.00178841439231 0)
(-0.000439837537619 -0.00170128612274 0)
(-0.000532847790053 -0.00170540074292 0)
(-0.000559908509774 -0.00144885490956 0)
(-0.00063512834606 -0.00135892715391 0)
(-0.000730910001835 -0.00144046221918 0)
(-0.000792158068231 -0.00147398495834 0)
(-0.000897566503094 -0.00152662889569 0)
(-0.00092766422975 -0.00138597729945 0)
(-0.00100539879644 -0.00135390937346 0)
(-0.00109302963684 -0.00137689961397 0)
(-0.00116040770047 -0.00134888980177 0)
(-0.00121029810519 -0.00128337010031 0)
(-0.0012853559817 -0.00124651119235 0)
(-0.00134467275542 -0.00118450053834 0)
(-0.00140336075881 -0.00112120206546 0)
(-0.00147840572507 -0.00107510006652 0)
(-0.0015403015754 -0.000994244587461 0)
(-0.00158156414644 -0.000882823325029 0)
(-0.00164744177743 -0.000809438157244 0)
(-0.00167062251249 -0.00075148636073 0)
(-0.00173425319763 -0.000733039604698 0)
(-0.00180616043999 -0.000721659452233 0)
(-0.00189660238096 -0.000693675077914 0)
(-0.00192846201154 -0.00063552173713 0)
(-0.00194827635596 -0.000580824949669 0)
(-0.0019884896051 -0.000537790688002 0)
(-0.00202352339988 -0.000492098692667 0)
(-0.00205148532372 -0.000441139412778 0)
(-0.00206346520751 -0.000388766505173 0)
(-0.00210296812146 -0.000332615494437 0)
(-0.00213468698549 -0.000268718918718 0)
(-0.00216099088306 -0.000204563923316 0)
(-0.00218085232673 -0.000140221268215 0)
(-0.0021943753417 -7.55669988057e-05 0)
(-0.00220516719039 -8.27280081958e-06 0)
(-0.00221153399172 6.67304998008e-05 0)
(-0.00219473188567 0.000152524285091 0)
(-0.002169165628 0.000237766387882 0)
(-0.00216268955485 0.000310445363719 0)
(-0.00215285789188 0.000370400757245 0)
(-0.00213489564792 0.000431302883488 0)
(-0.00211125192876 0.000510727956361 0)
(-0.00206140775951 0.000507443192817 0)
(-0.00166017386252 0.000394165077022 0)
(-0.00379930732774 0.00364998482046 0)
(0.0196377293185 0.025418131733 0)
(0.0364701359097 0.0410845422443 0)
(0.0529579085497 0.0544322157401 0)
(0.0691071454203 0.0655166648183 0)
(0.0847791781559 0.0744269517468 0)
(0.0999182287575 0.0812682949173 0)
(0.114513578841 0.0861776543722 0)
(0.128565629853 0.0893041205343 0)
(0.142081080502 0.0907878349319 0)
(0.155076374067 0.090754156917 0)
(0.167576942846 0.0893120804977 0)
(0.179612816934 0.0865538282519 0)
(0.191212539696 0.0825522459956 0)
(0.202398742642 0.077354068087 0)
(0.213187756256 0.0709730398941 0)
(0.22359143729 0.0633855886085 0)
(0.23361810933 0.0545276811243 0)
(0.243271297832 0.0442901100382 0)
(0.252547114369 0.0325094400186 0)
(0.261433483019 0.0189409212186 0)
(0.270050884929 0.00335094671034 0)
(0.277705511872 -0.014765545057 0)
(0.284857392092 -0.0359799449838 0)
(0.291223750748 -0.0613334532479 0)
(0.296662537296 -0.0922897972095 0)
(0.301138939014 -0.131323277616 0)
(0.305698247426 -0.182718233339 0)
(0.314775872101 -0.254545559351 0)
(0.339638229969 -0.35727781721 0)
(-2.55205150364e-05 -0.00189041029431 0)
(-8.59544861112e-05 -0.00188900196989 0)
(-0.000162997525944 -0.00164595781565 0)
(-0.000269149704894 -0.00188577505181 0)
(-0.000295666197567 -0.00183914590513 0)
(-0.000351565931372 -0.00185218993506 0)
(-0.000432961767824 -0.00180093073272 0)
(-0.000494808135046 -0.00173364613369 0)
(-0.000550347435148 -0.00155606574207 0)
(-0.000630668549781 -0.00143801202475 0)
(-0.000728070098559 -0.0015132428706 0)
(-0.000788284398988 -0.00154717507852 0)
(-0.000890262580115 -0.0015994243974 0)
(-0.000922571539742 -0.00145682626017 0)
(-0.00100406793069 -0.00142735613587 0)
(-0.00109041343581 -0.00144604926361 0)
(-0.00115810234803 -0.00141466134502 0)
(-0.00120074921669 -0.00134502431983 0)
(-0.00127851780084 -0.00131478606034 0)
(-0.00133568547337 -0.00124692990991 0)
(-0.0013839208053 -0.00117419309544 0)
(-0.00146513221915 -0.00113577429601 0)
(-0.00152226143739 -0.00105581043459 0)
(-0.00156693208948 -0.000945087942156 0)
(-0.00164039686709 -0.000867063674956 0)
(-0.00167463685202 -0.000805301087219 0)
(-0.00173213130522 -0.000785893827971 0)
(-0.00180370142336 -0.000782888502444 0)
(-0.00184421879449 -0.000738270984742 0)
(-0.00192285867315 -0.000680922581218 0)
(-0.00195193228618 -0.000614623946105 0)
(-0.00197581996785 -0.000563789025419 0)
(-0.00199161628856 -0.000518834579215 0)
(-0.00205259872834 -0.000474535975436 0)
(-0.00208135082399 -0.000419391856911 0)
(-0.0021001386392 -0.000361035112964 0)
(-0.00213696489958 -0.000297581336349 0)
(-0.0021633870802 -0.00022946358448 0)
(-0.00218962779484 -0.000160339188295 0)
(-0.0022100432068 -9.01126344691e-05 6.51859688169e-29)
(-0.00222452621603 -1.55181114666e-05 -6.29323342968e-29)
(-0.00222101590994 7.28946276816e-05 0)
(-0.00219234506496 0.00016838758262 0)
(-0.00218366531547 0.000254187172517 0)
(-0.00218146160889 0.000330361147428 0)
(-0.00215546803015 0.000405361645378 0)
(-0.00208529966696 0.00049395961179 0)
(-0.0019064185542 0.000549837669908 0)
(-0.00186152744384 0.0004422291356 0)
(-0.00132430212261 -0.00015531341077 0)
(0.0174080576892 0.0232168712522 0)
(0.0347023028435 0.0418675576896 0)
(0.0515416484689 0.0576857967755 0)
(0.0681908838665 0.0708129061453 0)
(0.0844587808393 0.0814815990948 0)
(0.100195669779 0.0898758710206 0)
(0.11534988146 0.0961627155897 0)
(0.129915884657 0.100510278291 0)
(0.143908250165 0.103083822787 0)
(0.157353954084 0.10403610181 0)
(0.170290098624 0.103502302135 0)
(0.182761522848 0.101597860336 0)
(0.194817513539 0.0984169733751 0)
(0.206508333991 0.0940303005009 0)
(0.217882923681 0.0884809997245 0)
(0.228988802532 0.0817802031246 0)
(0.239873684302 0.0739030298095 0)
(0.250587524286 0.0647845855984 0)
(0.261184251809 0.0543143422403 0)
(0.271724030355 0.0423269754358 0)
(0.282264624368 0.0285878307148 0)
(0.293034675958 0.0127701297805 0)
(0.30363351338 -0.00573199357941 0)
(0.314830905216 -0.0270612504715 0)
(0.32675647952 -0.0523345949027 0)
(0.339955479213 -0.0828924582188 0)
(0.355692419782 -0.120597373415 0)
(0.376656863246 -0.168155314745 0)
(0.406183356994 -0.229054677127 0)
(0.464942698976 -0.298965973358 0)
(-2.44084347089e-05 -0.00193605199284 0)
(-8.76882680347e-05 -0.00195172939172 0)
(-0.000173567478115 -0.00175383390028 0)
(-0.00025896860209 -0.00191558008659 0)
(-0.000276051261667 -0.0018596354319 0)
(-0.000337178778486 -0.00191272703333 0)
(-0.000414900944603 -0.00187677694067 0)
(-0.000452884854832 -0.00173392019257 0)
(-0.000545524415715 -0.00165655335723 0)
(-0.000625910054211 -0.00151465098176 0)
(-0.0007221824445 -0.00158233992332 0)
(-0.000781678204924 -0.00161853251797 0)
(-0.00087930237142 -0.00167008699349 0)
(-0.000912678552137 -0.00152910461689 0)
(-0.00099633041209 -0.00150286696409 0)
(-0.00108339133229 -0.00151533708563 0)
(-0.00114236872613 -0.00146975945398 0)
(-0.00118273512431 -0.00140226450593 -1.06411919528e-28)
(-0.00126857654684 -0.001384842594 1.08826091611e-28)
(-0.00132407652462 -0.00130761267317 0)
(-0.00136119512049 -0.00122185961068 0)
(-0.00144870243614 -0.0011917468161 0)
(-0.00151560693141 -0.00111975941923 0)
(-0.00155211881004 -0.00100756726612 0)
(-0.00163021707257 -0.000927808396827 0)
(-0.00167964464814 -0.000863870736879 0)
(-0.00172836925718 -0.000835201431416 0)
(-0.00181333363698 -0.000836847764843 0)
(-0.00182784214843 -0.000788620859534 0)
(-0.00189906901239 -0.000730475244584 0)
(-0.00194210105195 -0.000653702794376 0)
(-0.00200754523877 -0.000601258427494 0)
(-0.00201920492651 -0.000554421863642 0)
(-0.00203032550869 -0.000504760570224 0)
(-0.00207581028948 -0.000452109848956 0)
(-0.00210683509744 -0.000392031015983 0)
(-0.00213845956013 -0.000326689907496 0)
(-0.00216898913033 -0.000256348578375 0)
(-0.00219384074346 -0.000184168599077 0)
(-0.00222023033707 -0.000108169128563 0)
(-0.00223532988687 -1.90563434622e-05 0)
(-0.00221210821127 8.36304614457e-05 0)
(-0.00219526296509 0.000181121039629 0)
(-0.00219661828653 0.000269630045326 0)
(-0.00218263912714 0.000365734868234 0)
(-0.00212920574532 0.00047231469385 0)
(-0.00198125762721 0.000539363947696 0)
(-0.00194700886679 0.000465510173328 0)
(-0.00195366913744 7.53385470133e-05 0)
(0.0106244243372 0.0189079507043 0)
(0.0304042556653 0.0406574979388 0)
(0.0484342191326 0.0593083048663 0)
(0.0657615846451 0.0747695432103 0)
(0.0826160885621 0.0874118353841 0)
(0.0989191499691 0.0975211083212 0)
(0.114600928737 0.105313603599 0)
(0.129642542779 0.110988417264 0)
(0.144057922102 0.114737936266 0)
(0.157880680807 0.116743621698 0)
(0.171157803864 0.117170166563 0)
(0.183946041979 0.116161641061 0)
(0.196309084419 0.11383940029 0)
(0.208315029403 0.110300686324 0)
(0.220034393438 0.105617040253 0)
(0.231539237112 0.0998320149241 0)
(0.242903901497 0.0929583997791 0)
(0.254207324985 0.0849752930125 0)
(0.265536628059 0.0758247166538 0)
(0.276992054219 0.065406849337 0)
(0.288694285039 0.0535725706974 0)
(0.30079678247 0.0401124210885 0)
(0.313498631139 0.0247285147913 0)
(0.327320245447 0.00716865431268 0)
(0.341830722123 -0.0133958474803 0)
(0.358381051992 -0.0370002989366 0)
(0.377623788186 -0.0647093786642 0)
(0.40096440077 -0.0974724943057 0)
(0.431101840299 -0.13607424992 0)
(0.468846363613 -0.181029494808 0)
(0.542252672534 -0.227562901657 0)
(-2.68334967515e-05 -0.00197343181975 0)
(-8.99828245372e-05 -0.00201719381062 0)
(-0.000170183005617 -0.00185400998927 0)
(-0.000240512982562 -0.00190785108582 0)
(-0.000279308792733 -0.00190568442073 -1.33121548765e-29)
(-0.000341542301255 -0.00196740213693 1.39632935297e-29)
(-0.00041242587363 -0.00195412049649 0)
(-0.000449511318345 -0.0017907561488 0)
(-0.000568985910517 -0.00182389583539 0)
(-0.000617186380875 -0.00159662581638 0)
(-0.000713119924607 -0.00164717188987 0)
(-0.00077355015469 -0.00168810638801 0)
(-0.000866478676982 -0.00173817394691 0)
(-0.00090097920083 -0.00160139734228 0)
(-0.000983631267495 -0.00157886295035 0)
(-0.00107336548745 -0.00158714377203 0)
(-0.00110671063967 -0.00149744739209 0)
(-0.00116690391375 -0.00145566530624 0)
(-0.00126336498284 -0.00145569370556 0)
(-0.00131126244903 -0.00136353828265 0)
(-0.0013551416861 -0.00127743300064 0)
(-0.00144125495245 -0.00124519430238 0)
(-0.00153750343498 -0.00119348107781 -1.05431064801e-28)
(-0.00156409953305 -0.00106836711992 0)
(-0.00163122510812 -0.000986158921583 0)
(-0.00169047906921 -0.000922801672517 0)
(-0.0017335360236 -0.000885590348794 0)
(-0.00182392425089 -0.000884596088724 0)
(-0.0018384855031 -0.000835566406421 0)
(-0.00188771872197 -0.000778059024286 0)
(-0.00192975344072 -0.000705557803122 0)
(-0.0020094559045 -0.000642013768439 0)
(-0.00203303031455 -0.000577349781942 0)
(-0.0020527284738 -0.000532212042303 0)
(-0.00206754131594 -0.000481746504772 0)
(-0.00209686646618 -0.000423766153825 0)
(-0.00213214946588 -0.000358623525581 0)
(-0.00216901512285 -0.00028596079959 0)
(-0.00220020827993 -0.000209942607851 0)
(-0.00222656514784 -0.000123728808954 0)
(-0.00222107942504 -1.65069678011e-05 0)
(-0.00219992359698 9.39830569907e-05 0)
(-0.00219644361085 0.000191639147047 0)
(-0.0021933712067 0.000291596646488 0)
(-0.00216019489692 0.00042012105987 0)
(-0.00205999782592 0.000519906663048 0)
(-0.00196012271828 0.00038554590279 0)
(-0.00232802659466 0.000240148153918 0)
(0.00015488889661 0.0132644988511 0)
(0.0244484282695 0.0383117072097 0)
(0.0435714301542 0.0592837616291 0)
(0.0617760324507 0.0771688823646 0)
(0.0793114071114 0.0920011725938 0)
(0.0961853064964 0.104020476921 0)
(0.1123787371 0.113475926051 0)
(0.127874452447 0.120600825206 0)
(0.142681540323 0.125620388677 0)
(0.156835216487 0.128748827202 0)
(0.170389130804 0.130183513109 0)
(0.183409477093 0.130100528081 0)
(0.195971151362 0.128651989526 0)
(0.208155028135 0.125964695797 0)
(0.220046047602 0.122139431352 0)
(0.231732202165 0.117250349426 0)
(0.243304680029 0.111344069061 0)
(0.254859424112 0.104438442675 0)
(0.266500217518 0.0965210674985 0)
(0.278343357893 0.0875474208402 0)
(0.290524254868 0.0774382863129 0)
(0.30320685003 0.0660761588241 0)
(0.316597661448 0.0533007208874 0)
(0.330964538051 0.0389047748386 0)
(0.346708963844 0.0226251669238 0)
(0.364371742286 0.00415131708355 0)
(0.384166873889 -0.0171493832613 0)
(0.407601223363 -0.0409250373317 0)
(0.43570927216 -0.0677140550865 0)
(0.470713883125 -0.0975972704952 0)
(0.51221505661 -0.129896554899 0)
(0.587689796176 -0.161786544544 0)
(-3.27170998196e-05 -0.00203660824624 0)
(-9.42704461681e-05 -0.0020794956003 0)
(-0.00015631420351 -0.00194384660077 0)
(-0.000232788188321 -0.00197337685377 0)
(-0.000296490589641 -0.00197220174636 0)
(-0.000353743680134 -0.00201665327633 0)
(-0.000421673706233 -0.00201919114988 0)
(-0.000460801253817 -0.00184263015653 0)
(-0.000562246765082 -0.00189519663725 0)
(-0.00060011915379 -0.00167838323351 0)
(-0.000698335000824 -0.001714302312 0)
(-0.000763866924657 -0.00175792672828 0)
(-0.000853466176474 -0.00180429463793 0)
(-0.000890678198894 -0.00167372492964 0)
(-0.000973727463525 -0.00165396347287 0)
(-0.00106375270863 -0.00165941587553 0)
(-0.00110666158816 -0.00156768256119 0)
(-0.00117642328264 -0.00152811039026 0)
(-0.0012747557191 -0.00152800545511 0)
(-0.00131042862931 -0.00141747371628 0)
(-0.00138166953793 -0.00135135518959 0)
(-0.0014809694069 -0.00132251489888 0)
(-0.0015536326242 -0.0012515626744 1.01746911858e-28)
(-0.00165281396908 -0.00116896861037 0)
(-0.00166848383428 -0.00104055088995 0)
(-0.00173054057915 -0.000974653491379 0)
(-0.00176018999198 -0.000932464347416 0)
(-0.00184561132962 -0.000927354222768 0)
(-0.00185948022667 -0.000875494570149 0)
(-0.00189981203109 -0.000820355936145 0)
(-0.00193171173776 -0.000753135443303 0)
(-0.00198094589542 -0.000682623286746 0)
(-0.00205114151209 -0.000617285193497 0)
(-0.00207224050473 -0.000555958300275 0)
(-0.00208229747161 -0.000501793083522 0)
(-0.00209484627664 -0.000449390787792 0)
(-0.00212064880014 -0.000390608765544 0)
(-0.00215623538179 -0.000318912068324 0)
(-0.00219906377908 -0.000235742792571 0)
(-0.00221053357339 -0.000131392941224 0)
(-0.00219659248036 -1.18531133698e-05 0)
(-0.00219073467422 9.9409363693e-05 0)
(-0.00219881852782 0.000200912038145 0)
(-0.00220116449003 0.000318255930992 0)
(-0.00213314105351 0.000438953133202 0)
(-0.00204654215625 0.000399697414108 0)
(-0.00273972350872 0.000154881362173 0)
(-0.0016937184736 8.93099563048e-05 0)
(0.0195806679568 0.0325584102501 0)
(0.0381925066885 0.0569440602104 0)
(0.0565951307164 0.0776289592081 0)
(0.0746661923474 0.0949531922265 0)
(0.0921025955163 0.109149931757 0)
(0.108800317298 0.12047675925 0)
(0.124738167845 0.129208448394 0)
(0.139921539943 0.135613795722 0)
(0.154382194712 0.139947143284 0)
(0.168175897645 0.142443789899 0)
(0.18137531619 0.143315882954 0)
(0.194064133009 0.142749616334 0)
(0.206333186846 0.140903909327 0)
(0.218277996043 0.137910159959 0)
(0.229997372002 0.133872575743 0)
(0.241593115969 0.128868668077 0)
(0.253170898177 0.122949644533 0)
(0.264842450311 0.116140612798 0)
(0.276729191435 0.108440620349 0)
(0.288967444551 0.0998225522825 0)
(0.301715581882 0.0902329106395 0)
(0.315163755495 0.0795916549731 0)
(0.329547241168 0.0677926950763 0)
(0.34516465025 0.0547065339947 0)
(0.362400326993 0.0401853840381 0)
(0.381807379996 0.0241164340215 0)
(0.404097984372 0.0063656586512 0)
(0.429732309018 -0.0137533555411 0)
(0.460391162981 -0.0350852159536 0)
(0.497598208317 -0.0572897721759 0)
(0.540369892916 -0.07935265675 0)
(0.612277010439 -0.0999880894285 0)
(-3.36457559903e-05 -0.0021183777767 0)
(-9.13427139625e-05 -0.00213235597397 0)
(-0.000139111789904 -0.00201514467777 0)
(-0.000224984601397 -0.00204882579738 0)
(-0.000303695729037 -0.00203251283245 0)
(-0.000356782074194 -0.00206374048846 0)
(-0.000423244161765 -0.00208064758149 0)
(-0.000461616728871 -0.00189400427542 0)
(-0.000552022834419 -0.00193606656691 0)
(-0.000596618803094 -0.0017634975635 0)
(-0.000686763889042 -0.0017825522788 0)
(-0.000755422992091 -0.00182878958485 0)
(-0.000840938599114 -0.00186900885201 0)
(-0.000881157861793 -0.00174683794974 0)
(-0.00096603350937 -0.00172988904179 0)
(-0.00105480243694 -0.00173004703825 0)
(-0.00111107628049 -0.00164447079931 0)
(-0.00118875050143 -0.00160428727205 0)
(-0.00129215502474 -0.00160184140685 0)
(-0.00133114137487 -0.00149308200421 0)
(-0.00145269255048 -0.00147318675383 0)
(-0.0015181872305 -0.00140251064026 0)
(-0.00158897269544 -0.00132373981124 0)
(-0.00166661252715 -0.00122967333713 0)
(-0.00174786861853 -0.00113192713854 0)
(-0.00182326244359 -0.00105202484784 0)
(-0.00182062489391 -0.000974934393868 0)
(-0.00188221566277 -0.00096101186102 0)
(-0.00190454323824 -0.00091538607082 0)
(-0.00193036530064 -0.000854777765782 0)
(-0.00195640997116 -0.000787753178372 0)
(-0.00197597739414 -0.000720399294877 0)
(-0.0020341508608 -0.000654772083473 0)
(-0.00207271444163 -0.000585223595798 0)
(-0.00209731977713 -0.000523616275582 0)
(-0.00211140640167 -0.000468830742502 0)
(-0.00212082202237 -0.000414928026616 0)
(-0.00214320928539 -0.000348075029646 0)
(-0.00218228843244 -0.000256805527585 0)
(-0.00218242574487 -0.00013651480161 0)
(-0.0021794664131 -1.38546569747e-05 0)
(-0.00219090290318 9.39921241144e-05 0)
(-0.00222295492525 0.000192119182681 0)
(-0.00223562870388 0.000269869859249 0)
(-0.00227116418421 0.000353635364893 0)
(-0.00277605564935 0.000486699740487 0)
(-0.00179684213534 -0.000282562380943 0)
(0.00902198279079 0.0228784697187 0)
(0.0308929592351 0.0515366526314 0)
(0.0502040410914 0.0758209616307 0)
(0.0687419690518 0.0960137701234 0)
(0.0867128414532 0.112669027442 0)
(0.103936949427 0.126117049774 0)
(0.12033380258 0.136656565631 0)
(0.13589938992 0.144597997096 0)
(0.150664585254 0.15024316191 0)
(0.164685642591 0.153872311777 0)
(0.178039172595 0.155739213483 0)
(0.190815751556 0.156068509761 0)
(0.203114548386 0.155054475405 0)
(0.215039746087 0.15286109883 0)
(0.226698443258 0.149623092131 0)
(0.238199779313 0.145447389085 0)
(0.249655205242 0.140414801973 0)
(0.261179903744 0.134581640458 0)
(0.272895402724 0.127981229948 0)
(0.28493345512 0.120625378297 0)
(0.297441308807 0.112505917658 0)
(0.310588595831 0.103596547033 0)
(0.324576221478 0.0938554029191 0)
(0.339647773733 0.08322915723 0)
(0.356103988851 0.071660022296 0)
(0.374320840692 0.0590977681132 0)
(0.394770185229 0.0455179477171 0)
(0.418047589775 0.0310012577802 0)
(0.44505509509 0.0159694053851 0)
(0.476349974631 -2.49478052367e-05 0)
(0.51330756145 -0.0163329894996 0)
(0.555332631659 -0.0311069556427 0)
(0.622651107901 -0.0433275459164 0)
(-3.03961647958e-05 -0.00218591030005 0)
(-8.28142052257e-05 -0.00218453666348 0)
(-0.00012939241106 -0.00207740384636 0)
(-0.000220733034994 -0.00219245512671 0)
(-0.000290425623175 -0.00209715275716 0)
(-0.000349603342663 -0.00212027140259 0)
(-0.000416173626737 -0.00214175727071 0)
(-0.000459837341021 -0.00196762072798 0)
(-0.000554879330689 -0.00200849054738 0)
(-0.000600659389339 -0.00184314191711 0)
(-0.000680400292033 -0.00184705505737 0)
(-0.000749099773692 -0.00189939286292 0)
(-0.000827738826613 -0.00193079859472 0)
(-0.000870867600364 -0.00182068629386 0)
(-0.000957228519868 -0.00180691264381 0)
(-0.00104198234876 -0.00180062367287 0)
(-0.00111001283916 -0.00172814006639 0)
(-0.001191511202 -0.00168299827541 0)
(-0.00129801911391 -0.00167866760999 0)
(-0.00133921061049 -0.00157035223779 0)
(-0.00146098105522 -0.00155163335635 0)
(-0.00151107267998 -0.00146456041109 0)
(-0.00159559167554 -0.00139719153991 0)
(-0.00166327519965 -0.00129989719496 0)
(-0.00171770908969 -0.00118109142701 0)
(-0.00179864838193 -0.00108806695712 0)
(-0.00186770752837 -0.0010213660765 0)
(-0.00191488651696 -0.000991552036844 0)
(-0.00195159183762 -0.000951957787903 0)
(-0.00196779180541 -0.000883961275323 0)
(-0.00200036220256 -0.000813938212854 0)
(-0.00201660597987 -0.000746517592044 0)
(-0.00203287731918 -0.000678354770643 0)
(-0.00207256499898 -0.000612418067011 0)
(-0.00207813368338 -0.000541558290885 0)
(-0.00210800483233 -0.000485332637569 0)
(-0.0021200169216 -0.000432292471641 0)
(-0.00213310950378 -0.000368300918709 0)
(-0.00215452704593 -0.000271929250848 0)
(-0.0021559973257 -0.00014639901036 0)
(-0.00216897975264 -2.7978515115e-05 0)
(-0.00219594414527 6.75970176587e-05 0)
(-0.00224765431106 0.000144682459067 0)
(-0.0023637788127 0.000193281826159 0)
(-0.00232304716579 -1.45719477066e-05 0)
(-0.0023815194501 -0.000342693070429 0)
(-0.00488263440687 0.00749961698142 0)
(0.0226738621701 0.0435923855375 0)
(0.0423279951399 0.071182758052 0)
(0.06154960929 0.0947491584125 0)
(0.0801058756216 0.114283939606 0)
(0.0978615111183 0.130163906949 0)
(0.114741780274 0.142763026935 0)
(0.130715824533 0.152437317086 0)
(0.1458035758 0.159537866223 0)
(0.160060822145 0.164397156576 0)
(0.173567266885 0.167318120271 0)
(0.186419055229 0.168569918011 0)
(0.198722661592 0.168386786243 0)
(0.210590101237 0.166968470474 0)
(0.222135790915 0.16448181938 0)
(0.23347490908 0.161063130459 0)
(0.244723026419 0.156820857707 0)
(0.255996867578 0.151838408168 0)
(0.267416133635 0.146176882603 0)
(0.279106357342 0.139877736628 0)
(0.291202798172 0.132965449136 0)
(0.303855422166 0.125450388124 0)
(0.317235057266 0.11733218794 0)
(0.331540850698 0.10860414259 0)
(0.347009139025 0.0992594165547 0)
(0.363923708011 0.0893003033656 0)
(0.382627116241 0.0787522920229 0)
(0.40353225569 0.0676855474457 0)
(0.42713237505 0.0562459880618 0)
(0.453972721781 0.0447054768104 0)
(0.484709594422 0.033663110411 0)
(0.520275486439 0.0240634513177 0)
(0.559841569577 0.0166772994488 0)
(0.620558384731 0.0126803256907 0)
(-3.34524826965e-05 -0.00224261949122 0)
(-7.73750845564e-05 -0.00223918229022 0)
(-0.000126637941122 -0.00215233980449 0)
(-0.000209051869968 -0.00225740248175 0)
(-0.000265435864969 -0.00216557705568 0)
(-0.000334204587108 -0.0021863237619 0)
(-0.000403659351216 -0.00220286673827 0)
(-0.000456380132748 -0.00204946850635 0)
(-0.00054857546633 -0.00207443581207 0)
(-0.000600086709951 -0.00192131950847 0)
(-0.000673872988232 -0.00190580861401 0)
(-0.000742412721379 -0.00196819432563 0)
(-0.000811862504296 -0.00198704378012 0)
(-0.000861305893446 -0.00189470890209 0)
(-0.000948171185064 -0.00188393344019 0)
(-0.0010259762363 -0.00187055224034 0)
(-0.00110615057698 -0.00181529395844 0)
(-0.00118821034489 -0.00176242031307 0)
(-0.00129351926812 -0.00175606427579 0)
(-0.00133705371862 -0.00165125670343 0)
(-0.00144529972566 -0.00162339558854 0)
(-0.00149294728351 -0.00152347408181 0)
(-0.00156582214567 -0.00144673855089 0)
(-0.00168278112305 -0.00138888475718 0)
(-0.00173837241965 -0.00126481556221 0)
(-0.00181757577968 -0.00115944380846 0)
(-0.00187343223123 -0.00106015040092 0)
(-0.00196639331984 -0.001031012583 0)
(-0.00200508559333 -0.000990607404891 0)
(-0.00201192960837 -0.000913163617522 0)
(-0.00204686448611 -0.000841316939698 0)
(-0.00209004532414 -0.000773692160566 0)
(-0.00210113975378 -0.000698116664089 0)
(-0.00211550989098 -0.000624391144116 0)
(-0.00210491934637 -0.000554310710002 0)
(-0.0021122397074 -0.000496630309895 0)
(-0.0021153777811 -0.000442635986622 0)
(-0.00212056560439 -0.000380263695552 0)
(-0.00212317441242 -0.000283794154377 0)
(-0.00212849479874 -0.000163413692342 0)
(-0.00215705690648 -5.50630297804e-05 0)
(-0.00220357480785 1.34067153653e-05 4.60992883706e-29)
(-0.0022949649003 3.88704666e-05 0)
(-0.00228899940682 4.18001686471e-05 0)
(-0.00283016157667 3.78914555947e-05 0)
(-0.00143691709027 -0.000830900899645 0)
(0.0120494017445 0.0304583707389 0)
(0.0336409258474 0.0629971117802 0)
(0.0532892654757 0.0906203142449 0)
(0.0723297760593 0.113557999154 0)
(0.0906429304391 0.132310392578 0)
(0.108035143167 0.147303245218 0)
(0.124450945926 0.158965776588 0)
(0.139895630272 0.167713621725 0)
(0.154417246104 0.173939160907 0)
(0.168096005305 0.178002711179 0)
(0.181032873077 0.180225966755 0)
(0.193341156657 0.180889661401 0)
(0.205140484364 0.18023414041 0)
(0.216552543515 0.178461558205 0)
(0.227698477702 0.175739049479 0)
(0.238697772713 0.172202434524 0)
(0.249668395337 0.167960113085 0)
(0.260727993282 0.163096919885 0)
(0.27199602276 0.157677840736 0)
(0.283596714617 0.151751603648 0)
(0.295662823684 0.145354264071 0)
(0.30834012904 0.13851300158 0)
(0.32179265544 0.131250453724 0)
(0.336208548664 0.123590055807 0)
(0.351806423851 0.115563056772 0)
(0.368841772942 0.107218151527 0)
(0.387612599976 0.0986349965207 0)
(0.40846284433 0.0899432656176 0)
(0.431780862959 0.0813492314889 0)
(0.45799020373 0.0731727282019 0)
(0.487520737266 0.0658624609684 0)
(0.520888880863 0.0601380855098 0)
(0.556898121002 0.0570292945939 0)
(0.609951011887 0.0578534539754 0)
(-3.44173112662e-05 -0.00229936919034 0)
(-7.75000290454e-05 -0.00222149902047 0)
(-0.000130339981582 -0.00223485486176 0)
(-0.000200672292779 -0.00230249229544 0)
(-0.000251776145709 -0.00222902911515 0)
(-0.000319704898875 -0.00225413337526 0)
(-0.000388429620453 -0.0022646880132 0)
(-0.000447277838663 -0.0021307323068 0)
(-0.000530886520225 -0.00213549582579 0)
(-0.000595759471515 -0.00201046307747 0)
(-0.000664217137491 -0.00195820125099 0)
(-0.000733679642796 -0.00203362581339 0)
(-0.000796095560134 -0.00204361465015 0)
(-0.000858265674104 -0.00197614184485 0)
(-0.000943035044317 -0.00195954412377 0)
(-0.00101573573097 -0.0019465765553 0)
(-0.00111249992957 -0.00192198533426 0)
(-0.00118275542844 -0.00184089158742 0)
(-0.00128236307261 -0.00182833717968 0)
(-0.00133602981379 -0.00173502491658 0)
(-0.00142668499827 -0.00168570296501 0)
(-0.00150392723759 -0.00161228877533 0)
(-0.00159252458659 -0.00153704514312 0)
(-0.00168402559149 -0.00145271813294 0)
(-0.00181058759663 -0.00137684140528 0)
(-0.00190367286705 -0.00126384644764 0)
(-0.00192601076665 -0.00112549945885 0)
(-0.0020787569963 -0.00109833767335 0)
(-0.00208036886807 -0.00102191173117 0)
(-0.00208838578056 -0.000944354607263 0)
(-0.0020996901656 -0.000868551674771 0)
(-0.00213973197572 -0.000794419920945 0)
(-0.00215223672934 -0.000705929929626 0)
(-0.0021889841837 -0.000625784802662 0)
(-0.00216626470286 -0.000545457106093 0)
(-0.0021405247407 -0.00048478727002 0)
(-0.00212246340151 -0.000435909787713 0)
(-0.00210613438877 -0.000381210977391 0)
(-0.00208736768361 -0.000294035237895 0)
(-0.0020998836074 -0.000189621937953 0)
(-0.00213838795589 -0.000105306460293 0)
(-0.00225522977095 -4.82960863084e-05 -4.67317847204e-29)
(-0.00229192567238 1.13732192276e-05 0)
(-0.00217835455876 -0.000213278552664 0)
(-0.00204363755528 -0.000690866552702 0)
(-0.00435998668955 0.00809561306472 0)
(0.0236916207286 0.0509324412926 0)
(0.0437986898812 0.0831148402658 0)
(0.0634025496651 0.110049585114 0)
(0.0823001479767 0.132169461737 0)
(0.100251721329 0.149980774981 0)
(0.117159963344 0.163969519152 0)
(0.133010697096 0.174620543477 0)
(0.147842270071 0.182399009413 0)
(0.161731800884 0.187733441696 1.02296746085e-28)
(0.174783326123 0.191007773996 -9.77583240778e-29)
(0.187116793767 0.192557923713 0)
(0.198859793298 0.192671835991 0)
(0.210141866068 0.191592061932 0)
(0.221090830777 0.189519798723 0)
(0.231830817088 0.186619663725 0)
(0.242481749338 0.183024740969 0)
(0.253160008893 0.178841589474 0)
(0.263980037788 0.174155031973 0)
(0.27505670036 0.169032666562 0)
(0.286508268666 0.16352915412 0)
(0.298459934106 0.15769042641 0)
(0.3110477627 0.151558035898 0)
(0.324422989615 0.145173936877 0)
(0.338756468087 0.138586064498 0)
(0.354242922597 0.131855176726 0)
(0.371104377487 0.125063548758 0)
(0.389591686165 0.118326239774 0)
(0.409982555238 0.111805769484 0)
(0.432572968968 0.105730934163 0)
(0.457661886292 0.100420769293 0)
(0.485496471812 0.0963094932886 0)
(0.516413123422 0.0939994975784 0)
(0.548989812691 0.0942037685466 0)
(0.596109709248 0.0977865383597 0)
(-2.90857075099e-05 -0.00236089847348 0)
(-8.279919562e-05 -0.00228091051664 0)
(-0.000139998665959 -0.00229761520258 0)
(-0.000199780102657 -0.00235223093132 0)
(-0.000250257429686 -0.00228669748946 0)
(-0.000310575460515 -0.00231572242451 0)
(-0.000374038073175 -0.00232637248231 0)
(-0.000435267679536 -0.00221021063415 0)
(-0.000507228939305 -0.00219297421013 0)
(-0.000587551870127 -0.00210861379286 0)
(-0.000653447068724 -0.00200832444124 0)
(-0.000723946824576 -0.00209215616899 0)
(-0.000783439361993 -0.00211234286495 0)
(-0.000856689740503 -0.00205844364133 0)
(-0.000941551695281 -0.0020296468572 0)
(-0.0010123908164 -0.00202471478142 0)
(-0.00111439502275 -0.00202546717354 0)
(-0.00117337191064 -0.00192079587007 0)
(-0.00126361962428 -0.00189080041864 0)
(-0.00133500713368 -0.00182223737908 0)
(-0.00143235721328 -0.00177258620249 0)
(-0.00151527563705 -0.00170415997283 7.76630037586e-29)
(-0.0016536235491 -0.00167286033924 -8.02210137145e-29)
(-0.00173607598171 -0.00157768005669 0)
(-0.00185521549496 -0.00148467960936 0)
(-0.00192734904897 -0.00133733453301 0)
(-0.00198793976304 -0.00120480726149 0)
(-0.00211365347232 -0.00112981264307 0)
(-0.00220225804434 -0.00106165197901 0)
(-0.00220090755457 -0.000969583339524 0)
(-0.00219950023404 -0.000885826896434 0)
(-0.00221512751892 -0.000811935465614 0)
(-0.00224047217557 -0.000727763720308 0)
(-0.00226823420165 -0.000628062634645 0)
(-0.00227206002909 -0.000521971690748 0)
(-0.00220899590156 -0.000439942564837 0)
(-0.00215377339022 -0.000394519361306 0)
(-0.00208965972721 -0.000358372457058 0)
(-0.00203994433968 -0.000298841588878 0)
(-0.00204839704544 -0.000228959648104 0)
(-0.00214342113524 -0.000204134545653 0)
(-0.00232041336066 -0.000185887170063 0)
(-0.0022995545898 -6.74782215447e-05 0)
(-0.00287795355039 3.58533581493e-06 0)
(-0.0013357685698 -0.00100807243212 0)
(0.00999058756657 0.0332460497228 0)
(0.0332043067305 0.0710631237343 0)
(0.0534929501954 0.103020378076 2.28605769474e-28)
(0.0728825283396 0.129218283164 0)
(0.0914134092785 0.150402507555 0)
(0.10887251312 0.167160693374 0)
(0.125193462122 0.180057829898 0)
(0.140396363749 0.189643443898 0)
(0.154552126345 0.196429121303 0)
(0.167765661104 0.200874444761 0)
(0.180162758027 0.203381875637 0)
(0.191879415041 0.20429644067 0)
(0.203054072499 0.203908508796 0)
(0.213822502503 0.202458636593 0)
(0.224314847335 0.200143527014 0)
(0.234654386825 0.197122394343 0)
(0.244957681268 0.193523284405 0)
(0.255335767049 0.189449078203 0)
(0.265896127352 0.184983048383 0)
(0.27674522083 0.180193962828 0)
(0.287991411977 0.175140833375 0)
(0.299748194504 0.169877482176 0)
(0.312137617041 0.164457139999 0)
(0.325293788555 0.158937306031 0)
(0.339366240002 0.153385099783 0)
(0.354522729442 0.147883335761 0)
(0.370950792939 0.142537554393 0)
(0.3888569185 0.137484229693 0)
(0.408461843126 0.132900329061 0)
(0.429988975167 0.129014122829 0)
(0.453648244927 0.126117186624 0)
(0.479574913682 0.124573514358 0)
(0.508002570065 0.124837292653 0)
(0.537395366407 0.127413986703 0)
(0.579506320616 0.132795012758 0)
(-2.68912369827e-05 -0.0024189455564 0)
(-8.35056543164e-05 -0.00234362783622 0)
(-0.000141426919242 -0.00235501869559 0)
(-0.000201238713963 -0.00240974147194 0)
(-0.000251850734347 -0.00234037686751 0)
(-0.000303716071527 -0.00236856430233 0)
(-0.000360898528065 -0.0023863074799 0)
(-0.000424294697724 -0.00228562286182 0)
(-0.000485418805565 -0.00224615131629 0)
(-0.000580127146485 -0.00222180847851 0)
(-0.000642759348828 -0.00206618381013 0)
(-0.000715558158871 -0.00214321078304 0)
(-0.000770311466032 -0.00218356376894 0)
(-0.000860644024991 -0.00216339242526 0)
(-0.000936849026937 -0.00209488679456 0)
(-0.00100915040459 -0.00209853370993 0)
(-0.00110664368954 -0.0021132458314 0)
(-0.00115877637269 -0.00200083751521 0)
(-0.00125262409059 -0.00197174716315 0)
(-0.00133237700865 -0.00191293473878 0)
(-0.00143027420741 -0.00186329025862 0)
(-0.00152137964678 -0.00180282407029 0)
(-0.00162466947424 -0.00173891174825 0)
(-0.00171785273201 -0.00165564956394 0)
(-0.0018283596957 -0.00156841073075 0)
(-0.00197891226791 -0.00147363322715 0)
(-0.00205680722348 -0.00132285097045 0)
(-0.00218534618398 -0.00121943063812 0)
(-0.00237631263289 -0.00113815286282 0)
(-0.00237597880494 -0.00100264503214 0)
(-0.00240511632626 -0.00091048797782 0)
(-0.0023866328145 -0.000821672651678 0)
(-0.00238878348521 -0.000733179396844 0)
(-0.00237035454123 -0.000621442832735 0)
(-0.00239956956204 -0.000495853502609 0)
(-0.00235584171608 -0.000366867049258 0)
(-0.00224710764794 -0.00029332688379 0)
(-0.00208858491717 -0.000282451505708 0)
(-0.00196169867302 -0.000288816014108 0)
(-0.00197333253036 -0.000278283833794 0)
(-0.00211672708395 -0.000300907594121 0)
(-0.00218215952783 -0.000344251129727 0)
(-0.00219924761804 -0.000541643362727 0)
(-0.00236094729613 -0.000864771758341 0)
(-0.00709357122789 0.00281426237738 0)
(0.0223575297983 0.054551918998 0)
(0.0423407382362 0.091649398595 0)
(0.0623346596367 0.122778912318 -1.937605607e-28)
(0.0815241047132 0.148063024315 0)
(0.0995942789686 0.168161078727 1.33572682197e-28)
(0.116458893773 0.183752992829 0)
(0.132110692978 0.195487448031 0)
(0.146605399378 0.203973302605 0)
(0.160045344253 0.209762022347 0)
(0.172561129704 0.213337708877 0)
(0.184297428835 0.215115179275 0)
(0.1954027866 0.215442851203 0)
(0.206022636197 0.214608424899 0)
(0.216295021732 0.212846138127 0)
(0.226348507653 0.21034467018 0)
(0.236301773777 0.207255035795 0)
(0.24626445846 0.203698057347 0)
(0.256338874188 0.199771195574 0)
(0.266622286197 0.195554672223 0)
(0.277209522987 0.19111694676 0)
(0.28819577007 0.186519707184 0)
(0.29967946704 0.181822586572 0)
(0.311765258379 0.177087815039 0)
(0.324566916374 0.172384966998 0)
(0.338210042742 0.167795884095 0)
(0.352834155944 0.163419762785 0)
(0.368593491629 0.159378303659 0)
(0.385655446868 0.155820714749 0)
(0.404195354987 0.152928249957 0)
(0.424384680441 0.150917684086 0)
(0.446376795272 0.150043314024 0)
(0.470244051772 0.15059408721 0)
(0.496177352531 0.152894665132 0)
(0.522620231649 0.157269354511 0)
(0.560370244886 0.163906907611 0)
(-2.5068916055e-05 -0.00247080660102 0)
(-7.87602580169e-05 -0.00240332983687 0)
(-0.000139205418427 -0.00240670298416 0)
(-0.000202563053923 -0.00246745627992 0)
(-0.000248908753942 -0.00239005805224 0)
(-0.000293145486111 -0.00240993473424 0)
(-0.000344955196818 -0.00244386673829 1.1305707208e-29)
(-0.000416101663115 -0.00235692747824 -1.08297225119e-29)
(-0.00047803489844 -0.00229748459434 0)
(-0.000573309598274 -0.00235533016812 0)
(-0.00062176897908 -0.00213702995384 0)
(-0.000704792040208 -0.00219195438666 0)
(-0.000760039680324 -0.00225155395888 0)
(-0.000864660204586 -0.00229417603646 0)
(-0.000916089084609 -0.00216123887521 0)
(-0.000998650358241 -0.00217232835156 0)
(-0.00109140364206 -0.00219210494509 0)
(-0.00114173635092 -0.00208089423386 0)
(-0.00124006690061 -0.00205973370112 0)
(-0.00133776943909 -0.00201711706579 0)
(-0.0014229571559 -0.0019503821051 0)
(-0.00155038282984 -0.0019402293987 0)
(-0.00161087106371 -0.00183459238477 0)
(-0.00170887542446 -0.00175902736653 0)
(-0.00182172971765 -0.00168524136918 0)
(-0.00195316102998 -0.00159027911632 0)
(-0.00209444075946 -0.00147526689808 0)
(-0.0022139550768 -0.00135664968237 0)
(-0.00246808808748 -0.00125623192927 0)
(-0.00260812669022 -0.00109104123646 0)
(-0.00264657622945 -0.000949522378702 0)
(-0.00269582026913 -0.000844071459741 0)
(-0.0026718753196 -0.000733289099937 0)
(-0.00266976827576 -0.000615688401411 0)
(-0.00260217691986 -0.000459980960938 0)
(-0.00259148761249 -0.000277776561542 0)
(-0.00246666346864 -0.000107192505409 0)
(-0.00218770639496 -8.53327363396e-05 0)
(-0.00180577800644 -0.000226402510611 0)
(-0.0018710212668 -0.000380061570411 0)
(-0.00213330599245 -0.000400426012302 0)
(-0.00209104133928 -0.0002224364338 0)
(-0.00174394355975 -0.000625681958224 0)
(-0.00142570295057 -0.00119193273746 0)
(0.00490045689136 0.0294356738809 0)
(0.0304788401396 0.0745996762652 0)
(0.0509450539739 0.111933346755 0)
(0.070557534567 0.142229265012 0)
(0.0892954117913 0.166439919865 0)
(0.106795161674 0.185330511694 -1.22550788623e-28)
(0.122986805793 0.199672191309 0)
(0.137909801502 0.210197463362 1.01132625448e-28)
(0.151658308242 0.217571034649 0)
(0.164364611778 0.222377935824 0)
(0.176181843945 0.225119742479 0)
(0.187269902619 0.226216879614 0)
(0.19778587475 0.226015090239 0)
(0.207878040026 0.224794207399 0)
(0.217682663739 0.222777899441 0)
(0.22732293449 0.220143487307 0)
(0.236909460391 0.217031244556 0)
(0.246541817042 0.213552838357 0)
(0.256310727849 0.209798766585 0)
(0.266300549168 0.205844809832 0)
(0.276591839346 0.201757654457 0)
(0.287263906842 0.197599935963 0)
(0.298397332711 0.193434975289 0)
(0.310076511971 0.1893314222 0)
(0.322392227379 0.185367893073 0)
(0.335444147449 0.181637524297 0)
(0.349342930466 0.178252187185 0)
(0.36421134536 0.175345943037 0)
(0.380183439912 0.173077149012 0)
(0.397400639203 0.171628485898 0)
(0.4160018514 0.171203934141 0)
(0.436113147288 0.172022056138 0)
(0.457784886479 0.17430299936 0)
(0.481212241562 0.178256676143 0)
(0.504877945772 0.184050844601 0)
(0.538729619635 0.191627121965 0)
(-2.38272084965e-05 -0.00251910611807 0)
(-7.54286295378e-05 -0.00246093557074 0)
(-0.000141067421259 -0.00247906945132 0)
(-0.000200184141246 -0.00252072631746 0)
(-0.000235565623867 -0.00243636327933 0)
(-0.000277131021122 -0.00244582587353 0)
(-0.000326187003884 -0.00250052977592 0)
(-0.000404410470246 -0.00245476340933 0)
(-0.000467706430255 -0.00233840652145 0)
(-0.000541985458473 -0.00240054112281 0)
(-0.000595675003954 -0.00222386228706 0)
(-0.000685810675622 -0.00224379764715 0)
(-0.000747860420644 -0.00231812488006 0)
(-0.000836696780338 -0.00237168942977 0)
(-0.000880163982632 -0.00223372212239 0)
(-0.00097550112538 -0.00225002362521 0)
(-0.00106284301132 -0.00226327432675 0)
(-0.00112205032493 -0.00216430444476 0)
(-0.00122295781288 -0.00214877836093 0)
(-0.00134538830176 -0.0021496994177 0)
(-0.00140312296517 -0.00203615207814 0)
(-0.00152253289237 -0.00201844597413 0)
(-0.00158926739566 -0.00192786822355 0)
(-0.00170128992031 -0.00187082648864 0)
(-0.0018097865116 -0.0018052858426 0)
(-0.00192316994017 -0.00172301551502 0)
(-0.0020639980585 -0.00163037610567 0)
(-0.00220591870997 -0.00153168931978 0)
(-0.00235162459727 -0.00140347052417 0)
(-0.00272749489818 -0.00129241715803 0)
(-0.00285672674658 -0.00107159489171 0)
(-0.00298725270314 -0.000904346731473 0)
(-0.0029978363783 -0.000747359910637 0)
(-0.0030842080801 -0.000622313436041 0)
(-0.00307796416308 -0.000438209228218 0)
(-0.00303121437348 -0.000191937018287 0)
(-0.00291168365726 0.000136116574335 0)
(-0.00259460848197 0.00035588663664 0)
(-0.00165765636612 -4.07675843796e-06 0)
(-0.00170394310562 -0.00062145550739 0)
(-0.00213095610171 -0.000709449641515 0)
(-0.00216518983091 -0.000535382991902 0)
(-0.00423593004697 -0.000400337665115 0)
(-0.00118649540114 -0.000800610013262 0)
(0.0154700884567 0.0495697819691 0)
(0.0380511534175 0.0949906612743 0)
(0.0585647243571 0.13195998423 0)
(0.0779444608311 0.161301291514 0)
(0.0961447227631 0.184274341898 0)
(0.112987824045 0.201837274873 0)
(0.128450299098 0.21486165488 0)
(0.142609572276 0.224152087559 -9.60275145393e-29)
(0.155596810526 0.230420747106 8.95409986392e-29)
(0.1675725968 0.234278374355 0)
(0.178709226371 0.236236064027 0)
(0.189177700054 0.236712515374 0)
(0.199139307232 0.236044504314 0)
(0.208740923951 0.234498871519 0)
(0.218113104579 0.232284737663 0)
(0.227370177992 0.229565107821 0)
(0.236611676023 0.226467372362 0)
(0.245924536586 0.223092462558 0)
(0.255385635262 0.219522617251 0)
(0.265064318365 0.215827893904 0)
(0.275024755999 0.212071710682 0)
(0.285328096964 0.208315797009 0)
(0.296034548464 0.204624914811 0)
(0.307205571028 0.201071579773 0)
(0.318906341506 0.197740790756 0)
(0.331208495362 0.194734518346 0)
(0.344192937264 0.192175453361 0)
(0.357952252134 0.190209290833 0)
(0.372591886689 0.189004601667 0)
(0.388229200824 0.188749160041 0)
(0.404987412916 0.189641292755 0)
(0.422990877473 0.191875135422 0)
(0.442304156287 0.195617981936 0)
(0.463169375042 0.200983242786 0)
(0.484159454909 0.208001808447 0)
(0.514496189442 0.21638267098 0)
(-2.27609063825e-05 -0.00256807686774 0)
(-8.2596669202e-05 -0.00251895224057 0)
(-0.000150099566335 -0.00256080020455 0)
(-0.0001846358961 -0.00256328094723 0)
(-0.000210246099872 -0.0024805095251 0)
(-0.000258759835304 -0.00249671596181 0)
(-0.000308397610965 -0.00255434259828 0)
(-0.000378509718723 -0.00255580702037 0)
(-0.000440037270159 -0.00239951480825 0)
(-0.00050749241541 -0.00243939804259 0)
(-0.000577388443908 -0.0023391888722 0)
(-0.000658568209066 -0.00229564244631 0)
(-0.000725052212471 -0.00238204050477 0)
(-0.000791727655534 -0.00242269426448 0)
(-0.000843981341934 -0.00231549683491 0)
(-0.000943415293223 -0.00232908561265 0)
(-0.00102089274971 -0.00232367822809 0)
(-0.0011009217925 -0.00225943471204 0)
(-0.00120171141667 -0.00223572886904 0)
(-0.00130871486091 -0.00223355057652 0)
(-0.00136908861384 -0.0021266135973 0)
(-0.00147954209507 -0.00209557849859 0)
(-0.00156169286568 -0.00202767589445 0)
(-0.00168734888767 -0.00198922459297 -6.66453140613e-29)
(-0.00176410066023 -0.00190056844442 6.43313427569e-29)
(-0.00188087496184 -0.00184109319093 0)
(-0.00199277973847 -0.00176200340985 0)
(-0.00212264175114 -0.00167951767249 0)
(-0.00222387328609 -0.0015728615095 0)
(-0.00244210109457 -0.00147154841474 0)
(-0.00286606677317 -0.00134435220097 0)
(-0.0030451408977 -0.00108470037116 0)
(-0.00338827756879 -0.000916665295978 0)
(-0.00348496861952 -0.000710956546478 0)
(-0.00369619766265 -0.000507301818525 0)
(-0.00389288894162 -0.0002002664738 0)
(-0.00397394624997 0.000328659248406 0)
(-0.00388329880748 0.00158279260401 0)
(-0.00196928309556 0.000296684770605 0)
(-0.00131607598076 -0.000523347497414 0)
(-0.00187151542885 -0.00110524798548 0)
(-0.00204542544567 -0.00117916145715 0)
(-0.00215159939715 -0.00096026934578 0)
(-0.00444734777332 0.0110177855224 0)
(0.0244528462984 0.071581327937 0)
(0.0451156987454 0.115962551249 0)
(0.0653176722241 0.151772649754 0)
(0.0844030766625 0.17990473309 0)
(0.102034413646 0.201495736364 0)
(0.118172011638 0.217630887833 0)
(0.132870348758 0.229288481149 0)
(0.146251692184 0.237337607193 0)
(0.1584825947 0.242527045851 -8.6212562933e-29)
(0.16974901472 0.245483303274 0)
(0.180238454435 0.246718026754 -7.82971873753e-29)
(0.19012847787 0.246640452536 0)
(0.199580035474 0.245572113406 0)
(0.208734427907 0.243762050897 0)
(0.217712893323 0.241401350968 0)
(0.226617928186 0.238636291885 0)
(0.235535608842 0.235579746087 0)
(0.244538329539 0.232320721672 0)
(0.253687503247 0.228932126767 0)
(0.26303591991 0.225477040416 0)
(0.272629654491 0.222013956923 0)
(0.282509644711 0.218601559447 0)
(0.292713245547 0.215303505764 0)
(0.303276142074 0.212193471757 0)
(0.314234934925 0.209360361931 0)
(0.325630533987 0.206913248642 0)
(0.337512262036 0.204985300535 0)
(0.349942357237 0.203735706672 0)
(0.363000258256 0.203348332112 0)
(0.376786132779 0.204025567456 0)
(0.39142077969 0.205975247524 0)
(0.407048749044 0.209388619562 0)
(0.423784049845 0.214407269082 0)
(0.441960136075 0.221073051355 0)
(0.460300648706 0.229304465877 0)
(0.487472642068 0.238547243885 0)
(-2.39904532505e-05 -0.00261801641606 0)
(-9.2816475553e-05 -0.00261498493363 0)
(-0.000144287582083 -0.00260506641853 0)
(-0.000154711386712 -0.00255875194555 0)
(-0.000185737230238 -0.00252413269346 0)
(-0.000240445872654 -0.0025478053249 0)
(-0.000289332256664 -0.00260037389636 0)
(-0.000343463550523 -0.00261830809854 8.69087799579e-29)
(-0.000407511386672 -0.00248894530748 0)
(-0.00046835708551 -0.00248372953527 0)
(-0.000551175436128 -0.00245098115728 0)
(-0.000624904391391 -0.00234680453533 0)
(-0.000694222228822 -0.00243778909868 0)
(-0.000745734385321 -0.00247194831225 0)
(-0.000818789649281 -0.00240704235577 0)
(-0.000912954305399 -0.0024016836152 0)
(-0.000987815781701 -0.00240743620883 0)
(-0.00108046737648 -0.0023586939731 0)
(-0.00117533947945 -0.00231594229003 0)
(-0.00126358150434 -0.00229938842679 0)
(-0.00134021097958 -0.00222318871875 0)
(-0.00144401315378 -0.00218407425609 0)
(-0.00153913533473 -0.00213121305806 0)
(-0.00163798564157 -0.00206906438706 0)
(-0.00172242554548 -0.00200101389517 0)
(-0.00185033736709 -0.00197169146499 0)
(-0.00192255722711 -0.00187750718088 0)
(-0.00202914039646 -0.00180895123125 0)
(-0.0021398995554 -0.0017402583095 0)
(-0.00221149734644 -0.00163069077364 0)
(-0.00244943496502 -0.00155882528335 0)
(-0.00289688398063 -0.00148688134573 0)
(-0.00326582382953 -0.00129190806204 0)
(-0.0037920688157 -0.00115329566999 0)
(-0.00437165284227 -0.00105364792292 0)
(-0.00515769995599 -0.000984139032914 0)
(-0.00683252755325 -0.000966469400031 0)
(-0.00634929908946 -0.000566830805624 0)
(-0.0216638442381 -5.97020745437e-05 0)
(-0.0171358476678 0.00415054683596 0)
(-0.00173407366107 -0.000563727086465 0)
(-0.0020205343123 -0.00135455000596 0)
(-0.00170133209729 -0.00167323075137 0)
(0.00223207214163 0.0353365240272 0)
(0.0304884975324 0.0927568653047 0)
(0.0515824496637 0.136771959825 0)
(0.0714074592811 0.171305459385 0)
(0.089995148562 0.197987527615 0)
(0.106988417462 0.218048471876 0)
(0.122381592298 0.232674635564 0)
(0.136294702392 0.242936794652 0)
(0.148899037229 0.249757968298 0)
(0.160394110768 0.253911240829 0)
(0.17098648951 0.256027401993 0)
(0.180873755878 0.256608964129 7.64198912822e-29)
(0.190234985507 0.256047927866 7.28355656499e-29)
(0.199226183918 0.254644690124 0)
(0.207979184481 0.252626307294 0)
(0.216602832024 0.250163054926 0)
(0.225185493456 0.247382754889 0)
(0.23379814265 0.244382687148 0)
(0.24249743517 0.241239120374 0)
(0.251328327236 0.238014693532 0)
(0.260325975203 0.23476412791 0)
(0.269516924215 0.231538984109 0)
(0.278919905996 0.228392259262 0)
(0.288546795716 0.225383450555 0)
(0.298404326925 0.222584323226 0)
(0.308497024384 0.220085146809 0)
(0.318831571849 0.218000744806 0)
(0.329422599013 0.216475405143 0)
(0.34029976308 0.215685476912 0)
(0.351515846634 0.215838197218 0)
(0.363156036929 0.217164888202 0)
(0.375346013726 0.219905553879 0)
(0.388266422528 0.2242819048 0)
(0.402115533244 0.230453610901 0)
(0.417363845275 0.238437772816 0)
(0.432987248167 0.248096323636 0)
(0.457315494884 0.258512195802 0)
(-2.33215154096e-05 -0.0026649785417 0)
(-7.22672253565e-05 -0.00267192965337 0)
(-0.000114176134819 -0.00255090731955 0)
(-0.00014519944744 -0.00255978654773 0)
(-0.0001772514819 -0.00256876456573 0)
(-0.00022470009555 -0.00259768389122 0)
(-0.000264522699713 -0.00263717319786 0)
(-0.000308665545559 -0.00266744883318 -8.64003734301e-29)
(-0.000374196860469 -0.00256922399597 0)
(-0.000431262065306 -0.00251994623738 0)
(-0.0005196285953 -0.00258768117289 -8.04117964009e-29)
(-0.0005867935061 -0.00241857931773 0)
(-0.000664223832671 -0.002482602301 0)
(-0.000711320847836 -0.00254362489959 0)
(-0.000806207869088 -0.00252895644537 0)
(-0.000887230887136 -0.00246578359907 0)
(-0.000966223317745 -0.00249350743308 0)
(-0.00107669182349 -0.00250871555299 0)
(-0.00113975191553 -0.00239337575023 0)
(-0.00123571628328 -0.00238522258061 0)
(-0.00132677214484 -0.00232621315365 0)
(-0.00141447284306 -0.00226634025523 0)
(-0.00153396646462 -0.00226377224379 0)
(-0.00158049057073 -0.00214559648603 0)
(-0.00168311642667 -0.00209653436048 0)
(-0.00175989808523 -0.00203063426462 0)
(-0.00184186230598 -0.00196448752743 0)
(-0.00193522419963 -0.001909506917 0)
(-0.00202226626923 -0.00185032402978 0)
(-0.00210961284022 -0.00179869921746 0)
(-0.00217258885752 -0.00172439808071 0)
(-0.00236917780625 -0.00169036408548 0)
(-0.00265447496902 -0.00165517032473 0)
(-0.00305481694633 -0.00163882643219 0)
(-0.00345903547319 -0.0016543258527 0)
(-0.00386816262754 -0.00179441941459 0)
(-0.00418731426763 -0.00208912034821 0)
(-0.00358320732508 -0.00270892365408 0)
(-0.00396922065032 -0.00227685123943 0)
(-0.00280429571459 -0.000138677016836 0)
(-0.0184306047202 0.0136657113218 0)
(-0.00227927745928 -0.00100830933421 0)
(-0.00167429879327 -0.00162720255115 0)
(0.00940762069199 0.059815870296 0)
(0.0355820252737 0.114383032379 0)
(0.0571958245927 0.157410865922 0)
(0.0767990818648 0.190472981469 0)
(0.0947868880799 0.215483557292 0)
(0.111059141156 0.23387727053 0)
(0.125668996957 0.246937376445 0)
(0.138787049411 0.255801684558 0)
(0.150628494104 0.261430484729 0)
(0.161420912823 0.264607602825 0)
(0.171385324133 0.2659562701 0)
(0.180723325031 0.265960272915 0)
(0.189610145081 0.264987147838 -7.15070477593e-29)
(0.198192435765 0.263311086689 6.82752106258e-29)
(0.206589199328 0.261133901727 0)
(0.214894528092 0.258603173521 0)
(0.223181153475 0.255827291149 0)
(0.231504073782 0.252887412095 0)
(0.239903697999 0.249846532273 0)
(0.248408073091 0.246756066305 0)
(0.257033992725 0.243660676754 0)
(0.26578716871 0.240602407185 0)
(0.274662063374 0.23762522024 0)
(0.283642229374 0.234780704913 0)
(0.292701963149 0.23213510996 0)
(0.301809797841 0.229777233817 0)
(0.31093402293 0.227826269987 0)
(0.320050217102 0.226438524055 0)
(0.329150871711 0.225811846975 0)
(0.338257331946 0.226186418781 0)
(0.347435425785 0.22783991037 0)
(0.356813193341 0.231073228866 0)
(0.366611396265 0.236183188462 0)
(0.377137380969 0.243409203956 0)
(0.38903038735 0.252832044863 0)
(0.401720732122 0.264378785654 0)
(0.423394900603 0.276638005628 0)
(-2.00727472792e-05 -0.00270819394005 0)
(-5.01332804607e-05 -0.00270105411545 0)
(-9.7806933608e-05 -0.00268039177254 0)
(-0.000142998600377 -0.00260163283725 0)
(-0.000167622304769 -0.00261433804409 0)
(-0.000199104604551 -0.00264178465281 0)
(-0.000229269472841 -0.0026636939276 0)
(-0.000268128213667 -0.00271486186262 0)
(-0.000335605103996 -0.00264016828249 0)
(-0.000402564456247 -0.00256701233358 0)
(-0.000469916307906 -0.00264316708451 8.03143539694e-29)
(-0.000548906113579 -0.00252882765017 0)
(-0.000633564152414 -0.00251895496913 0)
(-0.000688302671836 -0.00261001858623 0)
(-0.000784393057264 -0.00267483639081 -7.64062168089e-29)
(-0.000844678670891 -0.00253875675191 0)
(-0.000941295923486 -0.00257069810625 0)
(-0.00103349315021 -0.00259270075472 0)
(-0.00110166958094 -0.00248392568018 0)
(-0.00120807247498 -0.00247389027842 0)
(-0.00132360032382 -0.00247065853958 0)
(-0.00137330066524 -0.00233686626018 0)
(-0.00147933415657 -0.0023205966753 0)
(-0.0015370039541 -0.00223486808284 0)
(-0.00164046353516 -0.00219072040188 0)
(-0.00169208474131 -0.00210161915037 0)
(-0.00177900996466 -0.00204854975637 0)
(-0.00184935645507 -0.00198963504522 0)
(-0.00191629344184 -0.00193045606643 0)
(-0.00198113711764 -0.0018839935023 0)
(-0.0020435727731 -0.00185956714408 0)
(-0.00205919138083 -0.00179771134662 0)
(-0.00213723668552 -0.00177283464187 0)
(-0.00224043146969 -0.00175907625987 0)
(-0.00233910982775 -0.00175159156844 0)
(-0.00240161616524 -0.0017848524154 0)
(-0.00238372399096 -0.00187790170852 0)
(-0.00214383632946 -0.00203142978802 0)
(-0.00172604022724 -0.00181895295159 0)
(-0.00155390190241 -0.00139383039402 0)
(-0.00156711859495 -0.000801705662921 0)
(-0.0241199412295 0.00309631109789 0)
(-0.0120858884216 0.00807632629789 0)
(0.0207583603393 0.0848517235252 0)
(0.0413234686148 0.136317162697 0)
(0.0623530626907 0.177622464462 0)
(0.0815652665242 0.209038966223 0)
(0.0988446694685 0.232264055393 0)
(0.11430860253 0.248916134508 0)
(0.128096662938 0.26039345873 0)
(0.140419716411 0.267888855283 0)
(0.151524562979 0.27238420495 0)
(0.161658148892 0.274660779794 0)
(0.17104846991 0.275323187234 0)
(0.179894627053 0.274827870606 0)
(0.188362765958 0.273511807663 0)
(0.196586311487 0.271619124714 -6.73006802868e-29)
(0.204668844826 0.26932428089 0)
(0.212688206031 0.266751256088 6.24560087988e-29)
(0.220700821433 0.263988768824 0)
(0.228745583965 0.261101780967 0)
(0.236846750364 0.258139621766 0)
(0.245015426167 0.255141320964 0)
(0.253249523892 0.252139247283 0)
(0.261532632233 0.249162573841 0)
(0.269832771038 0.246242035551 0)
(0.278102212061 0.243416812914 0)
(0.286279303967 0.240743458342 0)
(0.294292720198 0.238306013597 0)
(0.302068079518 0.236226147851 0)
(0.309536772629 0.234672280354 0)
(0.316647247205 0.233866967567 0)
(0.323379722849 0.234091944183 0)
(0.329767595618 0.235689455062 0)
(0.335925068711 0.239055962849 0)
(0.342100244746 0.244622744062 0)
(0.348704784085 0.252795192823 0)
(0.356534843982 0.263858697344 0)
(0.365797861538 0.277938524363 0)
(0.384365532296 0.29318853883 0)
(-1.94682689693e-05 -0.002749696574 0)
(-5.80774703558e-05 -0.00273713121624 0)
(-9.38108873758e-05 -0.00273565351764 0)
(-0.000115312303106 -0.00264624032545 0)
(-0.000132686235158 -0.00263971166638 0)
(-0.000157857336006 -0.00267406902249 0)
(-0.000188298045122 -0.0026946329494 0)
(-0.000225416879311 -0.00276103863391 0)
(-0.000292277418474 -0.00274137911454 0)
(-0.000365842071758 -0.00262853601488 0)
(-0.000417849766075 -0.00268153314186 0)
(-0.000504837637149 -0.00265646137191 0)
(-0.000592240819127 -0.00255344975792 0)
(-0.000663007512124 -0.00266124395032 0)
(-0.000716043536777 -0.0027122558239 7.51415133378e-29)
(-0.000794965248942 -0.00262964103001 0)
(-0.000899459835742 -0.00263889547674 0)
(-0.000974155981628 -0.00265438855034 -6.96070798123e-29)
(-0.00106754114046 -0.00258732747669 0)
(-0.00117290440081 -0.00254870520069 0)
(-0.00127053048427 -0.00253468173336 0)
(-0.00133454495495 -0.00242637626652 0)
(-0.00142981762722 -0.00238730793181 0)
(-0.00150615719287 -0.00232039329595 0)
(-0.00157838582914 -0.00224327313137 0)
(-0.001652608214 -0.00217931192867 0)
(-0.00171979113349 -0.00211419345695 0)
(-0.00176845010962 -0.00204167127054 0)
(-0.00183074243705 -0.00198953229716 0)
(-0.00187090482199 -0.00193184909677 0)
(-0.00192215904667 -0.00190588787628 0)
(-0.00191837395306 -0.00185785740636 0)
(-0.00192251731627 -0.00182864422627 0)
(-0.00188666397677 -0.0017742158944 0)
(-0.00188020008393 -0.0017628138679 0)
(-0.00183107129707 -0.0017572704695 0)
(-0.00174162644794 -0.00178215076027 0)
(-0.00154256855259 -0.00179218471664 0)
(-0.0012945043583 -0.00171873936592 0)
(-0.00119366517025 -0.00153198853019 0)
(-0.00114299889899 -0.00157184549074 0)
(-0.00117159267483 -0.0015333877894 0)
(0.0030438444635 0.0337717592584 0)
(0.0275803752271 0.104575743809 0)
(0.0474588321623 0.157174081078 0)
(0.0673082392812 0.197132712031 0)
(0.0857148865754 0.226825780392 0)
(0.102168884473 0.24821789262 0)
(0.116770525418 0.263114546505 0)
(0.129720383774 0.273034198224 0)
(0.141265432164 0.27921921762 0)
(0.151673599637 0.28266036984 0)
(0.161201726578 0.284124051629 0)
(0.170077187083 0.284186331059 0)
(0.178490498375 0.28326910515 0)
(0.18659420453 0.281674190177 0)
(0.194505536977 0.279613209335 0)
(0.202311035259 0.27723238592 0)
(0.210071707956 0.274632139901 -6.17809722538e-29)
(0.217827806505 0.271881915973 0)
(0.225602633948 0.269030716927 0)
(0.23340485922 0.266113771435 0)
(0.241228886266 0.263156155899 0)
(0.249053299165 0.26017498322 0)
(0.256838207405 0.257182312991 0)
(0.264522964372 0.254190629883 0)
(0.272025771313 0.251221612178 0)
(0.279246068644 0.248317574641 0)
(0.286069733982 0.245554120028 0)
(0.292376471172 0.243052525045 0)
(0.298048769501 0.240991114707 0)
(0.302982604705 0.239615943095 0)
(0.307101593846 0.23925210971 0)
(0.310380234406 0.24031709611 0)
(0.312879031498 0.243336250835 0)
(0.31483067701 0.248955661439 0)
(0.316697711781 0.257912008602 0)
(0.319432158548 0.270989945477 0)
(0.324301586453 0.288633923264 0)
(0.337406815632 0.309052734726 0)
(-1.70514841842e-05 -0.00278672492492 0)
(-5.94278251718e-05 -0.00277809020698 0)
(-8.244149056e-05 -0.00272846668945 0)
(-7.914137509e-05 -0.00264006281708 0)
(-9.31097124378e-05 -0.00264562330125 0)
(-0.000121917567238 -0.00269919085752 0)
(-0.000152818256627 -0.0027312265596 0)
(-0.000186567038452 -0.0028019598813 0)
(-0.000240320883357 -0.00282475961535 0)
(-0.000317032819817 -0.00271781613281 0)
(-0.000374194269779 -0.00270876066583 0)
(-0.000451267546858 -0.00282282869887 0)
(-0.000537333260937 -0.00265531509152 0)
(-0.000620321147154 -0.00269614776956 0)
(-0.000661203344122 -0.00278131773856 0)
(-0.000761805285546 -0.00278453275332 0)
(-0.000849728745655 -0.00270548986186 0)
(-0.000938259561333 -0.0027435971615 6.96762893267e-29)
(-0.00105181474264 -0.0027521336261 0)
(-0.00112866234691 -0.00263364443069 0)
(-0.00122893527925 -0.00261353063858 0)
(-0.00131286663521 -0.00252598887891 0)
(-0.00139568474945 -0.00245266826982 0)
(-0.00150223945507 -0.00243543691496 0)
(-0.00153733598114 -0.00231045768864 0)
(-0.00163792472 -0.00227198154929 0)
(-0.0016588002777 -0.00215132903639 0)
(-0.00172550207214 -0.00209976463391 0)
(-0.00177515205758 -0.00204240523214 0)
(-0.00180257997548 -0.00196829523311 0)
(-0.00183599678919 -0.0019176553494 0)
(-0.00185450317161 -0.00187541289236 0)
(-0.00186172707379 -0.00184430916163 0)
(-0.00184074356359 -0.00180330374236 0)
(-0.00180489804323 -0.00176502131616 0)
(-0.00174284131472 -0.00172666814216 0)
(-0.00162577964002 -0.00167450286029 0)
(-0.00142428492741 -0.001599026006 0)
(-0.00119227324152 -0.0015404525705 0)
(-0.000948968650698 -0.0014541047492 0)
(-0.000966735289427 -0.00175150615094 0)
(-0.00100783212506 -0.00193929383075 0)
(0.00355614062731 0.0545284075724 0)
(0.0316567822246 0.125990031409 0)
(0.0523634479501 0.177776251416 0)
(0.071561743659 0.216047037419 0)
(0.0891350888601 0.243819484411 0)
(0.104731138766 0.263311477707 0)
(0.118466210415 0.276461718483 0)
(0.130594112555 0.284876388417 0)
(0.14139832117 0.289831239495 0)
(0.151162500651 0.292311694751 0)
(0.16014575396 0.293057072288 6.99378504828e-29)
(0.168568116169 0.29260595994 -6.87278325471e-29)
(0.176606408412 0.291340003926 0)
(0.184396158637 0.289522870985 0)
(0.192036556362 0.287332701377 0)
(0.199596510453 0.28488775816 0)
(0.207120490205 0.282265748947 0)
(0.214633383779 0.279517704686 -5.7130893638e-29)
(0.222143914346 0.276677033367 0)
(0.229646034813 0.273764195712 0)
(0.237117795085 0.270788142182 0)
(0.24451793517 0.267746897313 0)
(0.251781613475 0.264630279763 0)
(0.258817380165 0.261426911392 0)
(0.265507173597 0.258135762363 0)
(0.271709923893 0.254780628454 0)
(0.277267995016 0.251425139185 0)
(0.28201488576 0.24818644069 0)
(0.285782674205 0.245247230496 0)
(0.288408591137 0.242867828193 0)
(0.28974198079 0.241402294132 0)
(0.289657233724 0.241324866386 0)
(0.288078560231 0.243277719761 0)
(0.285082063368 0.248151549635 0)
(0.280959267645 0.25720551353 0)
(0.27687761548 0.272271554938 0)
(0.27517961765 0.295116051888 0)
(0.278125019893 0.326377408308 0)
(-9.02600003733e-06 -0.00281423895798 0)
(-3.27059411679e-05 -0.00281433593345 0)
(-4.41008698467e-05 -0.00269764951293 0)
(-5.50738141662e-05 -0.0026101205112 0)
(-8.15864348057e-05 -0.00267382554239 0)
(-0.000101881059817 -0.00272369065637 0)
(-0.000122993400408 -0.00276144031152 0)
(-0.000143326383702 -0.0028287858496 0)
(-0.000175644662251 -0.00287749617696 0)
(-0.000248801124777 -0.0027954193356 0)
(-0.000328293504118 -0.00275233317403 0)
(-0.000371287459645 -0.00282538000145 0)
(-0.000464064294924 -0.0027982216962 0)
(-0.000557664702423 -0.00270009765811 0)
(-0.000623829573875 -0.00283934468232 0)
(-0.000700742097346 -0.00290381526035 0)
(-0.000789866851013 -0.00278367892651 0)
(-0.000905279937139 -0.00282058138723 0)
(-0.000995688227864 -0.00283046518563 0)
(-0.00108541508446 -0.00272473155024 0)
(-0.00119702129476 -0.00269195721232 0)
(-0.00130598512243 -0.00265943439694 0)
(-0.00136757855448 -0.00252541525963 0)
(-0.00145863628699 -0.00247937432775 0)
(-0.00151358461181 -0.00237583952455 0)
(-0.00158927401689 -0.00230121652859 0)
(-0.00164117803456 -0.0022165452072 5.11517196963e-29)
(-0.00170244553071 -0.00215602063682 -4.93579500754e-29)
(-0.00173427658512 -0.0020744668596 0)
(-0.00178039403762 -0.00201537947186 0)
(-0.00181450717451 -0.00195692870088 0)
(-0.0018448044576 -0.0019051131825 0)
(-0.00186741575545 -0.00185888961092 0)
(-0.00187339787771 -0.00180538134183 0)
(-0.00186779586749 -0.00175087798877 0)
(-0.00184386847498 -0.00168053061164 0)
(-0.00179381367549 -0.00158124543061 0)
(-0.00164663633195 -0.00141247815041 0)
(-0.00148471592452 -0.00130752074766 0)
(-0.000682862504678 -0.000891147107471 0)
(-0.000485596601209 -0.00144863174478 0)
(-0.00122998360785 -0.00158799741145 0)
(0.00895608839813 0.079460188874 0)
(0.0353144179786 0.147426414073 0)
(0.0564625181334 0.197859976221 0)
(0.0751491012759 0.234256769781 0)
(0.0918631994162 0.259979286822 0)
(0.106569445375 0.27753007785 0)
(0.119444034694 0.288967548014 0)
(0.130782548389 0.295953795817 0)
(0.140896492597 0.299775971677 0)
(0.150077855159 0.301398609377 0)
(0.158580501263 0.301522550904 0)
(0.166611068315 0.300641495895 0)
(0.174328618046 0.29909292782 0)
(0.181849459851 0.297101081934 0)
(0.189254043141 0.29481102766 0)
(0.196594020492 0.292314334204 0)
(0.203898344763 0.289667442407 0)
(0.21117785975 0.286904088436 5.66831986104e-29)
(0.218428034892 0.284042386375 5.38870185973e-29)
(0.22562910963 0.281086934445 0)
(0.232743058586 0.278027599184 0)
(0.239708045063 0.27483853335 0)
(0.246432643192 0.271481459083 0)
(0.252792706925 0.267915425743 0)
(0.258632757026 0.264112211694 0)
(0.26377176252 0.260074171428 0)
(0.268011360902 0.255850856614 0)
(0.271143699338 0.251552107658 0)
(0.272956233012 0.247357666884 0)
(0.273231465074 0.243525979643 0)
(0.271740668268 0.24040773243 0)
(0.268231357785 0.23847310635 0)
(0.262405958468 0.238371896433 0)
(0.253938585792 0.241055166477 0)
(0.242362961756 0.248054799264 0)
(0.228264534008 0.262023528313 0)
(0.213070691159 0.287568370542 0)
(0.199739521396 0.336136840125 0)
(-1.33248830737e-06 -0.00282643015103 0)
(-4.76051004309e-06 -0.00282939259051 0)
(3.87672038107e-06 -0.00272987406266 0)
(-3.41002589669e-05 -0.00266076211001 0)
(-8.31052530786e-05 -0.00268687346381 0)
(-8.37802122719e-05 -0.00273479016231 0)
(-8.81146879206e-05 -0.00277848744963 0)
(-9.13375294425e-05 -0.00283293374594 0)
(-0.000105460535409 -0.0029144522115 0)
(-0.000170831692556 -0.00290350158837 0)
(-0.000261249193607 -0.0028361391413 0)
(-0.000313809115564 -0.00285145237889 0)
(-0.000385860957156 -0.00298739288124 0)
(-0.000481806472059 -0.00281541105125 0)
(-0.000575058085835 -0.00287118286552 0)
(-0.000631172887752 -0.00297742163042 0)
(-0.000742229553301 -0.00296637857193 0)
(-0.000853151726308 -0.00290210227575 0)
(-0.000950759321067 -0.00292471115907 0)
(-0.00106933958791 -0.00289727270709 0)
(-0.00116327161863 -0.00277465023545 6.19391060962e-29)
(-0.00127412830358 -0.00273914554489 0)
(-0.00134996800019 -0.00261206498217 0)
(-0.00143601192324 -0.00252817145449 0)
(-0.00154041868585 -0.00249782333608 0)
(-0.00157308529913 -0.00235916908761 0)
(-0.00164003864249 -0.0022793003482 0)
(-0.00167478390635 -0.00218701385175 0)
(-0.00172353647328 -0.00212522240416 0)
(-0.00176865544997 -0.0020652725676 0)
(-0.00179244419101 -0.00198655432421 0)
(-0.00183763218252 -0.00193809114487 0)
(-0.00187283769487 -0.00188547831839 0)
(-0.00190577379519 -0.0018306515895 0)
(-0.00195566578729 -0.00178476146989 0)
(-0.00199900669512 -0.00171282413855 0)
(-0.00210794655769 -0.00163329024435 0)
(-0.00212077785857 -0.00148415373896 0)
(-0.00307419955971 -0.00153233319282 0)
(-0.00125366842957 -0.000281828636926 0)
(-0.0120469630904 -0.00768866101897 0)
(-0.00918429479824 0.00175407642826 0)
(0.0206161110092 0.10302340569 0)
(0.0400410599132 0.168643456182 0)
(0.0602394582291 0.217151819744 0)
(0.0781780657416 0.251559482956 0)
(0.0939467148999 0.275214833381 0)
(0.107726454893 0.290853548203 0)
(0.11975533561 0.30065284711 0)
(0.130351051195 0.306312832419 0)
(0.139836775886 0.309113889189 0)
(0.148502630298 0.309986328581 0)
(0.156590030846 0.309583533022 0)
(0.16428733679 0.308349242874 0)
(0.171733175926 0.306574936111 0)
(0.179023770072 0.304445805534 0)
(0.186221239656 0.302075456487 0)
(0.193361174948 0.29953076354 0)
(0.200458574249 0.296848692139 0)
(0.207511866554 0.294046850379 -5.39852586077e-29)
(0.214504728116 0.291128110423 -5.35529691024e-29)
(0.221404639191 0.288079492712 0)
(0.22815751942 0.284867864665 0)
(0.234679837288 0.28143775535 0)
(0.24085172165 0.277716509099 0)
(0.246514789044 0.273628503866 0)
(0.251476314645 0.269115642538 0)
(0.255518425024 0.264158655695 0)
(0.258408862351 0.25879410366 0)
(0.259909308308 0.253124483068 0)
(0.259777772442 0.247321897893 0)
(0.257762118177 0.24162832415 0)
(0.253582066685 0.236357373914 0)
(0.246892968156 0.231903899515 0)
(0.237219003561 0.228775044653 0)
(0.223845698161 0.22765493724 0)
(0.205404698118 0.229598482703 0)
(0.18008169063 0.236310858412 0)
(0.138542195289 0.251988306102 0)
(0.0818635601652 0.288610627046 0)
(-2.24464051646e-07 -0.00282330144171 0)
(-6.41565430937e-06 -0.00283031558748 0)
(2.82883359999e-06 -0.00272207653317 0)
(-6.78662329581e-06 -0.00283699846852 0)
(-4.07475689619e-05 -0.00271657594924 0)
(-4.73548887307e-05 -0.00273071109419 0)
(-4.13056288226e-05 -0.00277984645002 0)
(-3.49238051709e-05 -0.00282624861568 0)
(-3.58844982499e-05 -0.00294447789811 0)
(-7.38147742764e-05 -0.00298733895562 0)
(-0.000159603210167 -0.00292092323527 0)
(-0.000247111594889 -0.00289317192194 0)
(-0.000290291070587 -0.00297706783368 0)
(-0.000373114663037 -0.00299953465134 0)
(-0.000486762605581 -0.00290167052982 0)
(-0.000576043899363 -0.00303884856834 0)
(-0.00065578060255 -0.00309710785697 0)
(-0.000779705030371 -0.00297612928669 0)
(-0.000914130994776 -0.00299006955649 0)
(-0.00102239078102 -0.003005953322 0)
(-0.00112911387849 -0.00285677609501 -6.27414014337e-29)
(-0.00125985905499 -0.00280545569841 0)
(-0.00137699341853 -0.00275627392874 0)
(-0.00145201045151 -0.00261884197482 0)
(-0.00152706259298 -0.00252959793496 0)
(-0.00157694847088 -0.00241851343949 0)
(-0.00162274748553 -0.00231270347469 0)
(-0.00167144750292 -0.00223719711009 0)
(-0.00170120424127 -0.00215708957581 0)
(-0.00173152721286 -0.00208637848136 0)
(-0.00177145332583 -0.0020286282105 0)
(-0.00181464865224 -0.00198207511306 0)
(-0.00184605128301 -0.00192617712609 0)
(-0.00188711001626 -0.0018782871816 0)
(-0.00194015574136 -0.00183596653591 0)
(-0.002014823886 -0.00180053706901 0)
(-0.00211361522818 -0.00175400423276 0)
(-0.00221837736389 -0.00172811157896 0)
(-0.00283754548312 -0.00167691246691 0)
(-0.0014413309315 -0.00142969882443 0)
(-0.00881152520353 -0.0170122364822 0)
(0.00700951577217 0.0271062631791 0)
(0.0265049059244 0.120944733226 0)
(0.0448749307724 0.188202151879 0)
(0.0636437687744 0.235334663582 0)
(0.0805197256688 0.267824376393 0)
(0.0953182188641 0.289485598099 0)
(0.108201955803 0.303299822032 0)
(0.119439075169 0.311567012502 0)
(0.129361236992 0.316018510896 0)
(0.138293005244 0.317915402381 0)
(0.146515015136 0.318143230685 0)
(0.154251306713 0.317301345966 0)
(0.161669181066 0.315780696887 0)
(0.168885904105 0.313826768649 0)
(0.175978096826 0.31158745537 0)
(0.182990922823 0.309147347582 0)
(0.189945708926 0.306551031647 -5.55767475731e-29)
(0.196845378034 0.303817871067 0)
(0.203677687666 0.300950365974 5.36595753116e-29)
(0.21041594614 0.297935775696 0)
(0.217015604518 0.294741003246 0)
(0.223406086157 0.291304870615 0)
(0.229480475317 0.287535601971 0)
(0.235088281872 0.28331988331 0)
(0.240035738583 0.278543764862 0)
(0.244094442684 0.273119491243 0)
(0.247015244005 0.267009965782 0)
(0.248542275449 0.260244506042 0)
(0.248422294328 0.252923588061 0)
(0.246405768568 0.245213886292 0)
(0.242237221212 0.237336944888 0)
(0.235632836284 0.229554806375 0)
(0.226237321263 0.222154423152 0)
(0.213556293125 0.21543313699 0)
(0.196836450891 0.209666473649 0)
(0.174754524933 0.205090747958 0)
(0.145636743462 0.201486410978 0)
(0.102660704823 0.198437784271 0)
(0.0546147318049 0.187205845167 0)
(2.74831295388e-07 -0.0028190930547 0)
(-7.8236337344e-06 -0.00283498476789 0)
(-2.47022116526e-05 -0.00267580061001 0)
(6.14938385747e-06 -0.00276136149266 0)
(1.69611555014e-05 -0.00272301836544 0)
(-6.6135051496e-06 -0.00272425519749 0)
(9.21389008914e-06 -0.00276983600466 0)
(2.37312491776e-05 -0.00282659045906 0)
(4.31750659237e-05 -0.00294792710807 0)
(4.32817747443e-05 -0.00303257292 0)
(-2.42902502706e-05 -0.00303581425647 0)
(-0.000126253708677 -0.00299279575243 0)
(-0.000194577243499 -0.00298153653772 0)
(-0.00024858675677 -0.00309268865871 0)
(-0.000378383152742 -0.00308290260871 0)
(-0.000506285610937 -0.00305719481242 0)
(-0.000590521056402 -0.00319161504694 0)
(-0.000745986633262 -0.00327691367039 0)
(-0.000866745087114 -0.00307906966254 0)
(-0.00100212705648 -0.00312083637516 0)
(-0.001163103884 -0.00310624618711 0)
(-0.00126741564917 -0.00291265669529 0)
(-0.00139635397247 -0.00285239430283 0)
(-0.00146688288406 -0.0027013852093 0)
(-0.00153724464647 -0.00258530027748 0)
(-0.00160017152966 -0.00249066377542 0)
(-0.00162829001203 -0.00236309859406 0)
(-0.00166502593465 -0.00227474163572 0)
(-0.00167321389703 -0.00217875164138 0)
(-0.00171213628164 -0.00213003429048 0)
(-0.00173521992862 -0.00206955166976 0)
(-0.00174464433886 -0.00200174798829 0)
(-0.00176257269665 -0.00194997078171 0)
(-0.00179663200766 -0.00191613151855 0)
(-0.00183512786739 -0.00188392718597 0)
(-0.00187160879535 -0.00184565596005 0)
(-0.00190899976938 -0.00181735794468 0)
(-0.00195729981134 -0.00182011843523 0)
(-0.00193884452819 -0.0017371051814 0)
(-0.0017073523493 -0.00196052941543 0)
(-0.00109615959312 -0.00326773620553 0)
(0.00661654989292 0.0416880590951 0)
(0.0293793238776 0.140956689189 0)
(0.0478123603684 0.207287812568 0)
(0.0659052709373 0.252716122942 0)
(0.08194613077 0.283196723185 0)
(0.0959077590621 0.30288432744 0)
(0.10800336275 0.31495276047 0)
(0.11854351028 0.321794150061 0)
(0.127880563205 0.325153387625 0)
(0.136339857973 0.326257714626 0)
(0.144189677723 0.325937606737 0)
(0.151634594504 0.324733061975 0)
(0.158820204425 0.322980972056 0)
(0.165843080998 0.320882183955 0)
(0.172761834234 0.318549929168 0)
(0.179606713943 0.316042668855 5.55683020634e-29)
(0.18638691511 0.313385192858 5.52150068701e-29)
(0.193095252611 0.310580987146 0)
(0.199710491065 0.307618161098 0)
(0.206196813824 0.304467402897 0)
(0.212497978433 0.301071905431 0)
(0.21852579842 0.29733608461 0)
(0.224147531234 0.29312435049 0)
(0.229179516541 0.288276984334 0)
(0.233391878022 0.282640356475 0)
(0.23652341925 0.276101080138 0)
(0.238301222128 0.268612727656 0)
(0.238458229766 0.260208302978 0)
(0.236743768084 0.250997507015 0)
(0.232924185302 0.241151762662 0)
(0.226772816107 0.230881109443 0)
(0.218049160199 0.220405115097 0)
(0.206460492919 0.209917189963 0)
(0.191618528461 0.199536654686 0)
(0.172936420258 0.189219570232 0)
(0.149485360783 0.178663685702 0)
(0.120190590648 0.1665880158 0)
(0.0807639243059 0.151027825724 0)
(0.0409171872463 0.122872903863 0)
(6.845224041e-06 -0.00282273130039 0)
(1.89750070667e-05 -0.00285005792828 0)
(-2.28693070742e-05 -0.00269954575849 0)
(-1.01501884453e-05 -0.00264810042284 0)
(3.68189408652e-05 -0.00278491430949 0)
(3.37622341068e-05 -0.00271285460712 0)
(6.29308732703e-05 -0.00274754324197 0)
(9.32346530023e-05 -0.0028092887607 0)
(0.00013151747928 -0.00290222088965 0)
(0.000161951368682 -0.00304855075829 0)
(0.000139757123248 -0.00312869479216 0)
(4.61423418194e-05 -0.00307780323014 0)
(-6.63975968898e-05 -0.00307566576756 0)
(-0.000130917095221 -0.00311086361517 0)
(-0.000223196720401 -0.00330444569139 0)
(-0.000390152099316 -0.00316294154018 0)
(-0.00054803488427 -0.00322373463113 0)
(-0.000670506865797 -0.00338171972178 0)
(-0.000809460907241 -0.00322667997982 0)
(-0.000991963363182 -0.00322675012193 0)
(-0.00115229618301 -0.00323186868454 0)
(-0.00126701061121 -0.00303087706957 0)
(-0.00140666143416 -0.00292933864223 0)
(-0.00149667873184 -0.00279038914776 0)
(-0.00156247792846 -0.00264570992255 0)
(-0.00159695244262 -0.00250299222024 0)
(-0.00163508351936 -0.00239923021924 0)
(-0.00163120967802 -0.00226949571706 0)
(-0.00165733709128 -0.00220886775704 0)
(-0.00167197931971 -0.00215511573891 0)
(-0.00164448407083 -0.00205912830977 0)
(-0.00164483000928 -0.00200743596153 0)
(-0.00164799221476 -0.00196979198585 0)
(-0.00166677125906 -0.00194831308655 0)
(-0.00167532519235 -0.00191159929873 0)
(-0.00169776596372 -0.00188544827069 0)
(-0.00171260934033 -0.00185211527376 0)
(-0.0017217333779 -0.001825194098 0)
(-0.00163201038987 -0.00170416005964 0)
(-0.000845676545262 -0.00138557614324 0)
(-0.00168404120687 -0.0034723634219 0)
(-0.000372111893665 0.065790037343 0)
(0.0300468205107 0.161612728028 0)
(0.0492172927497 0.226158972356 0)
(0.0670707533021 0.269535403397 0)
(0.0825073641463 0.297855144483 0)
(0.0957762427292 0.315544030968 0)
(0.107200778721 0.325921970425 0)
(0.117146374767 0.331432029484 0)
(0.125989135856 0.333805208532 0)
(0.134054928907 0.334217129974 0)
(0.141598300013 0.33343282794 0)
(0.148803759788 0.331928664094 0)
(0.155795917158 0.329987432477 0)
(0.162652376989 0.327767624261 -5.70156221172e-29)
(0.169415996202 0.325350925906 0)
(0.176104467266 0.322772641411 -5.52111648589e-29)
(0.18271704086 0.32004008528 0)
(0.189238275225 0.317142273389 0)
(0.195639412803 0.314053229429 0)
(0.201876455374 0.310725358814 0)
(0.207881246297 0.307073229489 0)
(0.213545997062 0.302958990798 0)
(0.218708800487 0.298195091747 0)
(0.223149909932 0.292570840004 0)
(0.226603122505 0.285894705971 0)
(0.228778552985 0.278036097829 0)
(0.229388368194 0.268952501778 0)
(0.228167463947 0.258696144107 0)
(0.224884591343 0.247401928663 0)
(0.21934253276 0.235262214947 0)
(0.2113691954 0.222493792074 0)
(0.200801000968 0.209298645036 0)
(0.187454730619 0.195817655045 0)
(0.171118801449 0.182062542769 0)
(0.151452342141 0.167809042235 0)
(0.128047703939 0.152500727108 0)
(0.100507198859 0.134071886669 0)
(0.0661053356626 0.1098647728 0)
(0.0328354973931 0.0730570062903 0)
(1.40225785334e-05 -0.00281784472376 0)
(3.60101591406e-05 -0.00286017537221 0)
(-3.23833036304e-06 -0.00286092535852 0)
(-2.7903306308e-05 -0.0026226379009 0)
(4.24300611875e-05 -0.00282577155062 0)
(0.000100900625009 -0.00271796557748 0)
(0.000132315441295 -0.00271115945535 0)
(0.000178353143316 -0.00277325478761 0)
(0.000221936198589 -0.00284715371219 0)
(0.000276990373595 -0.00303104101624 0)
(0.000296553337816 -0.00313992246503 0)
(0.000255034895371 -0.00326672004611 0)
(0.000138223516284 -0.00318758228893 0)
(1.24127487458e-05 -0.00318414700417 0)
(-7.29459026375e-05 -0.00335387793036 0)
(-0.000241423936694 -0.00353524227388 0)
(-0.000460283088443 -0.00337088308381 0)
(-0.0006185710053 -0.00345839551866 0)
(-0.000777791561669 -0.00351681403739 0)
(-0.000961114883515 -0.00336166959023 0)
(-0.00115244358588 -0.00334520058407 0)
(-0.00131319967071 -0.00323171076193 0)
(-0.00144125791271 -0.00302708751764 0)
(-0.00154706268799 -0.00286385888495 0)
(-0.00159847588869 -0.00268932976192 0)
(-0.0016307933316 -0.00253866732479 0)
(-0.00163174633887 -0.00239532846939 0)
(-0.00163122148415 -0.00229178158482 0)
(-0.00162139375071 -0.00221395521684 0)
(-0.00157687503483 -0.00212047188256 4.35138308822e-29)
(-0.00154315260981 -0.00205523230352 -4.06108646883e-29)
(-0.0015173987501 -0.00201010337763 0)
(-0.00149323347707 -0.00197380437419 0)
(-0.00147480067785 -0.00194415598238 0)
(-0.00146275243139 -0.00191503781158 0)
(-0.00146499647576 -0.00188865843605 0)
(-0.0014934290852 -0.00187857254792 0)
(-0.00157220254215 -0.00184090122897 0)
(-0.0018654908279 -0.0017232906043 0)
(-0.0012798926597 -0.00166475537797 0)
(-0.0101370487342 -0.0195179809853 0)
(0.0074649008164 0.0893250949987 0)
(0.0314568150016 0.182077185657 0)
(0.0499736305071 0.244633645255 0)
(0.0675110352937 0.285819199777 0)
(0.0824023778709 0.311892099164 0)
(0.0950591060936 0.327568895159 0)
(0.105903590945 0.336307730442 0)
(0.115344791053 0.340573038247 0)
(0.123774694129 0.342055542397 0)
(0.13151610704 0.341862058633 -6.18261763129e-29)
(0.138808352171 0.340683189695 6.10359794887e-29)
(0.145816009433 0.338928861754 0)
(0.152644187518 0.336828871744 5.69283311634e-29)
(0.15935378714 0.334502268133 5.66211493331e-29)
(0.165974417166 0.332002471285 0)
(0.172513556712 0.329344429224 0)
(0.178962525945 0.32651996326 0)
(0.185299206259 0.323504610986 0)
(0.191488482794 0.320258136986 0)
(0.197478733899 0.316712013637 0)
(0.203188957189 0.31274562714 0)
(0.208488703935 0.308169338737 0)
(0.213182606255 0.302735181004 0)
(0.217011693457 0.296178870957 0)
(0.21967393449 0.288276656044 0)
(0.220856073118 0.278893805309 0)
(0.220265086704 0.268009145706 0)
(0.217650619227 0.255712835778 0)
(0.21281528737 0.24218330609 0)
(0.20561332461 0.227652371572 0)
(0.195942867749 0.212365293399 0)
(0.183732908529 0.196537789223 0)
(0.168928508034 0.180310451356 0)
(0.151516485777 0.163669916032 0)
(0.131385320157 0.146370487679 0)
(0.108719615484 0.127842608526 0)
(0.0836456213597 0.104959005704 0)
(0.0534125480979 0.075066087235 0)
(0.0241990910953 0.0350839111504 0)
(2.27815278875e-05 -0.0027801526892 0)
(4.41658457211e-05 -0.00285060325084 0)
(4.57229445299e-05 -0.00288812504406 0)
(1.42898210609e-05 -0.00259559792508 0)
(3.98046817301e-05 -0.00256656686444 -1.2000682745e-29)
(0.000120408946837 -0.00265986381146 3.27629145433e-33)
(0.000184315621896 -0.00266018231186 1.25887420334e-29)
(0.000260487376087 -0.00272341992049 0)
(0.000316370681041 -0.00280887433571 0)
(0.000388823002551 -0.00295704100597 0)
(0.000453695161273 -0.00314059016494 0)
(0.000469717042766 -0.00325135697274 0)
(0.000405734804174 -0.00332097783323 0)
(0.000241840376015 -0.00334884060935 0)
(7.18789721206e-05 -0.00340732209549 0)
(-8.53520620075e-05 -0.0036999034757 0)
(-0.000326761574149 -0.00366228216182 0)
(-0.000564939471982 -0.0035953611945 0)
(-0.00073318446953 -0.00362338704026 0)
(-0.000944888564505 -0.00369788849238 0)
(-0.00114661467968 -0.00346542465512 0)
(-0.00137229906461 -0.00336710317589 0)
(-0.00154327738708 -0.00319912156992 0)
(-0.00162144617547 -0.00292693703111 0)
(-0.00167516846214 -0.00272670720151 0)
(-0.00168289370396 -0.00255521240723 0)
(-0.00164736989436 -0.00239458636662 0)
(-0.00160498408471 -0.00227742360146 0)
(-0.00152109125508 -0.00214909807419 0)
(-0.00145293562019 -0.00206946446718 0)
(-0.00138340670196 -0.00199593383966 0)
(-0.00132453774061 -0.00194344706028 0)
(-0.00128303527839 -0.0019219398278 0)
(-0.00124239510384 -0.00190281092811 0)
(-0.00121220882832 -0.00188751195655 0)
(-0.00120074131003 -0.00188424959445 0)
(-0.0011864977297 -0.00186637653003 0)
(-0.00131860317526 -0.00199483058055 0)
(-0.00163854226893 -0.00216738474553 0)
(-0.00174071458695 -0.0024289879512 0)
(-0.00142273621107 -0.00373551596209 0)
(0.0081174760497 0.107097264093 0)
(0.0324783758661 0.202163567754 0)
(0.050235476973 0.262798781893 0)
(0.0673336037056 0.301629541537 0)
(0.0817588827972 0.32538777811 0)
(0.0938888389063 0.339049496371 0)
(0.104231497131 0.346198413653 0)
(0.11324293453 0.349297598858 0)
(0.121326461605 0.349973576488 0)
(0.128798327724 0.349248500697 0)
(0.135881564088 0.34773120289 0)
(0.142721504399 0.34576386234 0)
(0.149405612784 0.343525318787 -5.65311620862e-29)
(0.155980457825 0.341098444382 0)
(0.162464794899 0.338511593348 0)
(0.168857961682 0.335761826122 0)
(0.175145024824 0.332827032249 0)
(0.181298396794 0.329669810457 0)
(0.187277412419 0.326234979978 0)
(0.193022942468 0.322429265147 0)
(0.198439345793 0.318088298369 0)
(0.203369234994 0.312959379857 0)
(0.207578575962 0.306725894031 0)
(0.210766115225 0.299070229362 0)
(0.21259555251 0.289746674681 0)
(0.212736910811 0.278634001302 0)
(0.210902354862 0.265753014597 0)
(0.20686824716 0.251251851397 0)
(0.200482496559 0.235370290166 0)
(0.191659612465 0.218396014686 0)
(0.180372646315 0.200620443638 0)
(0.166638996364 0.182298448821 0)
(0.150521593914 0.163616063797 0)
(0.13217512312 0.144616824022 0)
(0.111643422247 0.125254036311 0)
(0.0898776846316 0.105201882758 0)
(0.0667738938956 0.079190021877 0)
(0.0365031947381 0.0451972940474 0)
(0.000189923848281 -0.000181162861817 0)
(4.09322313452e-05 -0.00270817506748 0)
(8.43881846214e-05 -0.00282778005144 0)
(0.000119883064286 -0.00280971385261 0)
(9.26152132476e-05 -0.00265129121197 0)
(2.8339558541e-05 -0.00256966254117 0)
(6.91906399328e-05 -0.00259988175573 0)
(0.000192896849313 -0.00256620318442 0)
(0.000320527634782 -0.00264880920539 0)
(0.000408949702544 -0.00274652325658 0)
(0.000488152393892 -0.00283928474458 0)
(0.00061805134036 -0.00308561324932 0)
(0.000677435564836 -0.00320500200675 0)
(0.000719356368931 -0.00345547058172 0)
(0.000587360902007 -0.00348050640811 0)
(0.000321366306266 -0.00362908701551 0)
(5.32250100743e-05 -0.00380006318136 0)
(-0.000190296994702 -0.00398650847612 0)
(-0.000475564521062 -0.00375935099992 0)
(-0.000727970995695 -0.00377891769904 0)
(-0.000911018324853 -0.00381801654668 0)
(-0.00120549729672 -0.00389115232058 0)
(-0.00144450336334 -0.00352499894838 0)
(-0.0016784545175 -0.00330881996894 0)
(-0.00176277648133 -0.00300606518338 0)
(-0.00178102822639 -0.00274450721789 0)
(-0.00170842670353 -0.00249665467873 0)
(-0.00162515912713 -0.00232876090955 0)
(-0.00149484168512 -0.00215311197321 0)
(-0.00140114472464 -0.00205697032896 0)
(-0.00129499176546 -0.00196077819561 0)
(-0.00122408257566 -0.00191964660305 3.71423963557e-29)
(-0.00115654455337 -0.00189203787729 -3.42357232349e-29)
(-0.00109306329447 -0.00187527901742 0)
(-0.0010304273727 -0.00186023194509 0)
(-0.000991483195684 -0.00186575434319 0)
(-0.000942682435258 -0.00186154292075 0)
(-0.000964521627722 -0.00197511478812 0)
(-0.00109586684499 -0.00222189212786 0)
(-0.00135162484237 -0.00252499206851 0)
(-0.00150863066427 -0.00293288148365 0)
(-0.0018093530504 -0.0050312597685 0)
(0.00310620887107 0.127448433369 0)
(0.0319655537243 0.22274865036 0)
(0.0499960437004 0.280966492331 0)
(0.0667338472744 0.317119674806 0)
(0.0807551338572 0.338432400022 0)
(0.0924224926808 0.350060554778 0)
(0.102316935262 0.355662129371 0)
(0.11094875809 0.357666434049 0)
(0.118731276179 0.357610531134 -5.9737915727e-29)
(0.125970688322 0.356416659195 0)
(0.132872322401 0.354605992112 0)
(0.139562827161 0.352453015726 0)
(0.146113721088 0.350088426158 0)
(0.152559312311 0.3475623643 0)
(0.158909504413 0.344881116166 0)
(0.165157115463 0.342025932312 0)
(0.171282210043 0.338961908796 0)
(0.177252521843 0.335638803666 0)
(0.183022275767 0.331985275836 0)
(0.188524474476 0.327878030919 0)
(0.193646030489 0.323097939794 0)
(0.198197009899 0.317316259686 0)
(0.201898776317 0.310140513352 0)
(0.204405260768 0.301203978935 0)
(0.205348944235 0.290254428612 0)
(0.204391298545 0.277206057998 0)
(0.201260689874 0.262144418914 0)
(0.195771466905 0.245295413955 0)
(0.187825997533 0.22697538884 0)
(0.177403854657 0.207539070222 0)
(0.164551140949 0.187331066922 0)
(0.14935483755 0.166649783437 0)
(0.131952583634 0.14573003825 0)
(0.112535651036 0.124675536995 0)
(0.0911447403198 0.10381574628 0)
(0.0697982943335 0.0833877481011 0)
(0.0459404217365 0.0538473007398 0)
(0.000803245337604 0.00109084264173 0)
(-0.000321099970693 -0.000965256186407 0)
(6.91794537609e-05 -0.00260863437784 0)
(0.000162370740442 -0.00279923316235 0)
(0.000181640879395 -0.00273814914835 0)
(0.000158061208765 -0.00277425729161 0)
(6.2681911963e-05 -0.00260433078151 0)
(4.76844662341e-05 -0.00243881886991 0)
(0.000161069873727 -0.00234632872212 0)
(0.00032099196512 -0.00249643501159 0)
(0.000458151790081 -0.00264028259306 0)
(0.00057791018314 -0.00274752623153 0)
(0.000724949728137 -0.00289512345858 0)
(0.000908944798904 -0.00321281344128 0)
(0.000980698322536 -0.00333797270393 0)
(0.00106730797139 -0.00383331703485 0)
(0.000859681184469 -0.00403498292845 0)
(0.00030574252945 -0.00391758365569 0)
(-0.000165427659023 -0.00417282896334 0)
(-0.000438807023091 -0.00425487072374 0)
(-0.000645526967846 -0.00385728860399 0)
(-0.000903156227467 -0.00410249751729 0)
(-0.00122215234567 -0.00401959192867 0)
(-0.00167099112392 -0.00400034438943 0)
(-0.00186707536898 -0.00338543410142 0)
(-0.00198595110305 -0.00304381767976 0)
(-0.00188575246198 -0.00267545504271 0)
(-0.00171973137158 -0.00237279876686 0)
(-0.00155306926722 -0.00216513179137 0)
(-0.00141860679649 -0.00203901640569 0)
(-0.00129210818094 -0.00194183441192 0)
(-0.0011925078455 -0.00189249359111 0)
(-0.00109841072145 -0.00186313401618 0)
(-0.000997808038861 -0.00182504818185 0)
(-0.000906391573537 -0.00179775536734 0)
(-0.000834396013996 -0.00180070992963 0)
(-0.000775252442878 -0.00181974640865 0)
(-0.0007022908098 -0.00182273391288 0)
(-0.000712920677106 -0.00203680847721 0)
(-0.000768275537595 -0.00235399915298 0)
(-0.000931756810897 -0.00281070238219 0)
(-0.00127711667126 -0.00338901986079 0)
(-0.0012843613958 -0.00416653725595 0)
(0.00180035736989 0.147962084177 0)
(0.0311911990524 0.243481846322 0)
(0.049778695801 0.299132274928 0)
(0.0660996771131 0.332323065021 0)
(0.0796468879585 0.3510446382 0)
(0.0908390837779 0.360623770166 0)
(0.100293995066 0.364728327257 0)
(0.108564235441 0.365711592241 5.9571378789e-29)
(0.116066852092 0.364995518463 1.17267742044e-28)
(0.123092343743 0.363389398901 -5.74633496287e-29)
(0.129825538255 0.361323217037 0)
(0.13637417694 0.359005514001 0)
(0.142794966762 0.356522494774 0)
(0.149111467555 0.353895177464 0)
(0.155326194046 0.351110573679 0)
(0.161426543507 0.348135839312 0)
(0.167388395304 0.344924045934 0)
(0.173175180621 0.341411805917 0)
(0.178736118918 0.337509861194 0)
(0.183995489111 0.333057789302 0)
(0.18881877191 0.327767804515 0)
(0.192976498024 0.321220676216 0)
(0.196139077902 0.312942963333 0)
(0.197914169663 0.302528177499 0)
(0.197907994409 0.289738600674 0)
(0.195783258761 0.27454952721 0)
(0.191296101282 0.257135114131 0)
(0.184309604575 0.237817629383 0)
(0.174788629176 0.21700237502 0)
(0.162782403791 0.195118242264 0)
(0.148412215751 0.172561503052 0)
(0.131824996377 0.149660885775 0)
(0.113207920327 0.126652067556 0)
(0.0926240201543 0.103490941597 0)
(0.0698120154523 0.0804839559608 0)
(0.0472398145872 0.0580615873776 0)
(0.00246230004016 0.00382742094736 0)
(-0.000184305041632 -0.000134824694118 0)
(-1.8759952516e-05 -0.000699413795477 0)
(9.56870424822e-05 -0.00245632325865 0)
(0.000233459819274 -0.0027578701647 0)
(0.000244880252904 -0.00281364045005 0)
(0.000223015228813 -0.0028164406689 0)
(0.000172927122747 -0.00276465788366 1.22472267647e-28)
(0.000116187741592 -0.00243816021475 0)
(0.000134929684679 -0.00219168776116 0)
(0.000268270322079 -0.00234383394871 0)
(0.000453503888496 -0.00248264305753 0)
(0.000634235696296 -0.00260113557449 0)
(0.000806690525973 -0.00270357509182 0)
(0.00110380007309 -0.00301840888925 0)
(0.00124718360739 -0.00314321660421 0)
(0.00145178255245 -0.00370631608244 0)
(0.00129918467415 -0.00408915813999 0)
(0.00114760515794 -0.00579685288359 0)
(3.35507475777e-05 -0.00383132808868 0)
(-0.000661741327205 -0.00453183363619 0)
(-0.000453193119186 -0.00415627310867 0)
(-0.000705909243466 -0.0040779527703 0)
(-0.00142150311377 -0.00464411919732 0)
(-0.0019485137628 -0.00440394863105 0)
(-0.00240122694772 -0.00375948344544 0)
(-0.00220974853811 -0.00292541712907 0)
(-0.00198396797956 -0.00247492225887 0)
(-0.00172767787161 -0.00218205407128 0)
(-0.00152605284703 -0.00201842786455 0)
(-0.00136017138681 -0.00191762186408 0)
(-0.00120370100129 -0.00183609613868 0)
(-0.00107081884377 -0.00179294395232 0)
(-0.000927746558358 -0.00172819522541 0)
(-0.00082358791664 -0.00171067302017 0)
(-0.000734650204678 -0.00171470787876 0)
(-0.000653649278905 -0.00173385895908 0)
(-0.000562574460044 -0.00174648934639 0)
(-0.000470824084098 -0.00178879631184 0)
(-0.000411593627683 -0.00201859213126 0)
(-0.000321985935276 -0.00235321986126 0)
(-0.000316670005097 -0.00292858827918 0)
(0.000191319002977 -0.00311014604283 0)
(-0.0012803828332 -0.00297391536452 0)
(0.00296108243938 0.172626317917 0)
(0.0306719412273 0.264066723274 0)
(0.0499785409133 0.316978267117 0)
(0.0657751102602 0.347077131454 0)
(0.0786686749073 0.363133847368 0)
(0.0892924231392 0.370694003501 0)
(0.0982717456938 0.373383450898 0)
(0.10617005493 0.373436064615 -5.89111966401e-29)
(0.113393324285 0.37213678696 0)
(0.120208064555 0.370174076553 0)
(0.12677455377 0.367887045359 0)
(0.133180624985 0.365422279071 0)
(0.139468712187 0.362826133801 0)
(0.145652564685 0.360094325531 0)
(0.151728253731 0.357197233305 0)
(0.15767836565 0.354089336626 0)
(0.16347504051 0.350712157434 0)
(0.169077411774 0.34698849495 0)
(0.174429526044 0.342808850902 0)
(0.179445574959 0.337966222178 0)
(0.183964263195 0.332086930961 0)
(0.18770824 0.32464588009 0)
(0.190290653588 0.315087070364 0)
(0.191273112912 0.302979867872 0)
(0.190242768161 0.288127754365 0)
(0.186874849844 0.270595650131 0)
(0.180964960604 0.250670026503 0)
(0.172434560856 0.228786114877 0)
(0.161317242014 0.205448377617 0)
(0.14773647176 0.181167542029 0)
(0.131897007377 0.156394220758 0)
(0.114015085258 0.131495190478 0)
(0.0944170579886 0.106685352425 0)
(0.0732913304041 0.0814423175287 0)
(0.0502268461129 0.0555663595658 0)
(0.0189119326835 0.0292341910218 0)
(0.000235271935701 -7.27783195446e-06 0)
(0.00116451353928 -0.000791126871154 0)
(0.00022460911911 -0.000944864630328 0)
(0.000102647360809 -0.00224906938513 0)
(0.000271408642884 -0.00270158504014 0)
(0.000305869872615 -0.00281612725583 1.43623255747e-28)
(0.000296537832278 -0.0028294856739 0)
(0.000280088772893 -0.00277908730801 -1.39080878713e-28)
(0.000225201265925 -0.00251981515802 0)
(0.00015895784568 -0.00224696958589 0)
(0.000222908681629 -0.00216848147196 0)
(0.000423924420408 -0.00229547938078 0)
(0.000641736826853 -0.00239489658071 0)
(0.000887411954031 -0.00248859216821 0)
(0.00115428000914 -0.00257950226203 0)
(0.0017294473456 -0.00317555610923 0)
(0.0016909136136 -0.00315213852802 0)
(0.0027163286961 -0.00490592302997 0)
(0.000888389348563 -0.00337304329546 0)
(0.000588798982034 -0.00744294962637 0)
(-0.000392856528907 -0.00307149560756 0)
(-0.000784153679899 -0.00350607824973 0)
(1.59059929762e-05 -0.00521909494631 0)
(-0.000949170894406 -0.0036950298452 0)
(-0.00277303096999 -0.00408719595831 0)
(-0.00314932892319 -0.00373637215239 0)
(-0.00252435419669 -0.00265110342676 0)
(-0.0020303931778 -0.00214514173332 0)
(-0.00169678174602 -0.00191711437728 0)
(-0.00146642979274 -0.0018321384436 0)
(-0.00123284690711 -0.00172632613884 0)
(-0.00105744402661 -0.00167669722741 0)
(-0.000884611703522 -0.00161170508562 0)
(-0.000775844546859 -0.00161693893508 0)
(-0.000678754092432 -0.0016296342808 0)
(-0.000580073938604 -0.00163738709144 0)
(-0.000475606585073 -0.00164144321317 0)
(-0.000359523450421 -0.00164496122389 0)
(-0.000242036133743 -0.00168511131774 0)
(-0.000127049740185 -0.00190808997174 0)
(0.000141956512581 -0.00217060892254 0)
(-0.000176124662822 -0.00295199652985 0)
(-0.00111250900392 -0.00290692423695 0)
(-0.0296134122231 -0.0215055151424 0)
(0.014379053664 0.199550834542 0)
(0.0323319752463 0.284475966584 0)
(0.0508353257665 0.334008291919 0)
(0.0659003171103 0.361049077547 6.59488469472e-29)
(0.077943657103 0.374524439601 0)
(0.0878677703833 0.380182544576 0)
(0.0963116070667 0.381587293306 0)
(0.103813520656 0.380824388657 0)
(0.110747148502 0.379028817668 0)
(0.117345430229 0.37676755436 0)
(0.123740074499 0.374293854827 0)
(0.129997938401 0.371698754941 0)
(0.136147474075 0.368994356344 0)
(0.142193182235 0.366155075877 0)
(0.148125271552 0.363137174058 0)
(0.153921748207 0.359883627287 0)
(0.159551202346 0.356324652889 0)
(0.164968164922 0.352368230425 0)
(0.170111159459 0.347881684272 0)
(0.174882399621 0.342598978067 0)
(0.179086906129 0.336039561708 0)
(0.182389866711 0.327557060851 0)
(0.184341503606 0.316516516803 0)
(0.184459920889 0.302486067471 0)
(0.182322858413 0.285342397648 0)
(0.177630654914 0.265270061084 0)
(0.17022961992 0.242689597436 0)
(0.160106973136 0.21816180356 0)
(0.147366573651 0.19229608699 0)
(0.13220399927 0.165692640449 0)
(0.114904286665 0.138870586028 0)
(0.095744818699 0.112309729639 0)
(0.075320427012 0.0862815318838 0)
(0.0539394708438 0.0593076112644 0)
(0.0301124270474 0.0311574882548 0)
(0.000201400471571 -0.000569452909114 0)
(0.000168509505472 -0.00220572576198 0)
(0.000416254355953 -0.00152988519099 0)
(0.000128388615579 -0.00138370603504 0)
(7.97850108132e-05 -0.00200861308061 0)
(0.000264472681405 -0.00259794104082 0)
(0.000348002215347 -0.00279244159782 -1.60627873933e-28)
(0.000371205816337 -0.00285963112333 0)
(0.000382308218646 -0.00279662035663 0)
(0.000363282426952 -0.00258592640507 0)
(0.000236617830425 -0.00222646312013 0)
(0.00018607771329 -0.00200310491933 0)
(0.000348820211922 -0.00208178287719 0)
(0.000591507349854 -0.00215564843239 0)
(0.000868374705493 -0.00219851125346 0)
(0.00121541962378 -0.00224728629955 0)
(0.00149614507949 -0.00234415390543 0)
(0.00280429958521 -0.00369580501747 0)
(0.00223197804433 -0.0038125564969 0)
(0.00447005515573 -0.0109945502975 0)
(5.66190372248e-05 -0.00253053823183 0)
(-0.000498821545186 -0.00880236494586 0)
(-0.000384658124073 -0.00151530859778 0)
(-0.00304227210713 -0.00653997848253 0)
(-0.0063856122175 -0.00990430300847 0)
(-0.00706758363261 -0.00832856426379 0)
(-0.00270434722557 -0.00253330971446 0)
(-0.00266628775854 -0.00192392456069 0)
(-0.00193810846894 -0.00168297450512 0)
(-0.00157522753337 -0.00160966944519 0)
(-0.00128528578066 -0.00155951323497 0)
(-0.00105768454633 -0.00151937668175 0)
(-0.000865073998874 -0.00147457317405 0)
(-0.000747481970368 -0.00150097224844 0)
(-0.000645295761653 -0.00153340966223 0)
(-0.000525933764758 -0.00152142563551 0)
(-0.000414224322812 -0.00152016844099 0)
(-0.000300620142732 -0.00151701201076 0)
(-0.000180718202067 -0.00151007375114 0)
(-5.84075569674e-05 -0.00156721930499 0)
(7.42558697902e-05 -0.00171487341933 0)
(0.000719844281908 -0.00177362415257 0)
(-0.00115115058309 -0.00428357193905 0)
(-0.0414011299308 -0.0356591689487 0)
(-0.0180426816952 0.0254126206222 0)
(0.0191559014166 0.219051366625 0)
(0.0363563028736 0.303136548492 0)
(0.0526069748983 0.349764548476 0)
(0.0663981528424 0.373941748153 -6.39427316408e-29)
(0.0774243169188 0.385052048151 0)
(0.0865568178557 0.389007933982 0)
(0.0944201641581 0.389301649603 0)
(0.101506461492 0.387858918383 0)
(0.108140680172 0.385662042898 0)
(0.114515155546 0.383162477449 0)
(0.120730809857 0.380536548797 0)
(0.126833304229 0.377827967376 0)
(0.132837616332 0.375020755646 0)
(0.138739449509 0.372072046549 0)
(0.144523564251 0.368926327913 0)
(0.150163370861 0.365516015464 0)
(0.155623977189 0.361760074353 0)
(0.160854756072 0.357550314878 0)
(0.165788280227 0.352727257369 0)
(0.170312324825 0.346949536134 0)
(0.174189515507 0.339604718712 0)
(0.177017005089 0.32991107763 0)
(0.178277805897 0.317165428649 0)
(0.17745202342 0.300965722862 0)
(0.174120340975 0.281298481646 0)
(0.16802207318 0.258497835799 0)
(0.159065158409 0.233136228792 0)
(0.147308085203 0.205905661032 0)
(0.132921006792 0.177515366292 0)
(0.11615442115 0.148648312109 0)
(0.097327613155 0.119881861788 0)
(0.0767278572078 0.0919100062963 0)
(0.0554714984383 0.0652384635058 0)
(0.0333615400876 0.0365340962244 0)
(0.000394943093466 -0.00013051973595 0)
(-0.000166276234907 -0.00140863305993 0)
(4.01965062846e-05 -0.00167991058449 0)
(0.00014758424636 -0.00161072212948 0)
(5.78223132284e-05 -0.00157591717764 0)
(5.35126492967e-05 -0.00187169668881 0)
(0.000225624903884 -0.00242968942134 0)
(0.000361305303397 -0.00275771659238 0)
(0.000402242122049 -0.00282232785027 0)
(0.00047455462022 -0.00280415621752 0)
(0.000472616263901 -0.00261192353376 0)
(0.000446277676448 -0.00262883063479 0)
(0.0002447550373 -0.0019751752262 0)
(0.00024251953242 -0.00184940986928 0)
(0.00046167490238 -0.0018925754154 0)
(0.000741708443091 -0.00188227992002 0)
(0.00107583221908 -0.00186582142766 0)
(0.00130285172402 -0.00188945380667 0)
(0.00220430158579 -0.00250856770498 0)
(0.001024406916 -0.00154923396219 0)
(0.0010992070244 -0.0123842225345 0)
(-0.00373375189117 -0.00894358034577 0)
(-0.00308321926045 -0.00829929099298 0)
(-0.0051782731291 -0.00682612132104 0)
(-0.00757104838931 -0.00960826350654 0)
(-0.00696513156376 -0.00758270883249 0)
(-0.00719753569525 -0.0066694130479 0)
(-0.00196772168327 -0.000664399488405 0)
(-0.00218882840563 -0.00111116217134 0)
(-0.00162650978943 -0.00121153881394 0)
(-0.00132201564254 -0.00129305641266 0)
(-0.00106085502892 -0.00131064226176 0)
(-0.000859123523335 -0.00131397083285 0)
(-0.00072777689167 -0.0013604379792 0)
(-0.000619056924513 -0.00141365588172 0)
(-0.000484721803597 -0.00139870491716 0)
(-0.000367903194182 -0.0014038505889 0)
(-0.00025737129387 -0.00140940504888 0)
(-0.000149638608413 -0.00140881963993 0)
(-4.80856926782e-05 -0.00140416372696 0)
(4.97973380041e-05 -0.00145694932451 0)
(7.80575102514e-05 -0.00157312180952 0)
(0.000688992424249 -0.00163661824012 0)
(-0.0141932600185 -0.0493170515935 0)
(-0.0421881014057 -0.0300236864547 0)
(-0.00446747760623 0.0738353222697 0)
(0.0217922632974 0.238157972803 -1.02554870918e-28)
(0.0397523115027 0.320398716214 0)
(0.0545046263038 0.364244277107 0)
(0.066990159924 0.385685893552 0)
(0.0769669840387 0.394652884309 0)
(0.0852916928796 0.397134998599 0)
(0.0925666289683 0.396510270389 0)
(0.09923489026 0.394531474631 0)
(0.105567562086 0.392030300192 0)
(0.111714336179 0.389352424126 0)
(0.117745627245 0.386608265327 0)
(0.123686850741 0.383803209226 0)
(0.129540457128 0.38089942029 0)
(0.135293867483 0.377840543109 0)
(0.14092680603 0.374561393674 0)
(0.146407935236 0.370984523003 0)
(0.151698958205 0.367017514794 0)
(0.15674331977 0.362534284925 0)
(0.161467253434 0.357344127328 0)
(0.165740980629 0.351009133898 0)
(0.169273929372 0.342755866236 0)
(0.171584008072 0.331656389614 0)
(0.172084902011 0.31695925679 0)
(0.17022769531 0.298331961133 0)
(0.165611154321 0.27591134202 0)
(0.158028876914 0.250210018286 0)
(0.147462090957 0.221965738883 0)
(0.134047505229 0.191999963904 0)
(0.118019945974 0.161103305628 0)
(0.0996683673302 0.130010318952 0)
(0.0792740427536 0.099244195303 0)
(0.0569837932418 0.0695955785792 0)
(0.0344367878598 0.0417285291065 0)
(0.00089934727733 0.00101921486655 0)
(-0.000154658402948 -0.000945046675256 0)
(-4.55753009682e-05 -0.0013141358443 0)
(4.78313559836e-06 -0.00157003049135 0)
(3.76697716421e-05 -0.00162813469598 0)
(1.61974884698e-05 -0.0016225332342 0)
(5.99491021818e-05 -0.00177286839679 0)
(0.000211227746788 -0.00221161386231 0)
(0.000344460180972 -0.00269529262979 0)
(0.000376522359209 -0.00275175218683 0)
(0.000476611091549 -0.002679172155 0)
(0.000633510320249 -0.00268545149859 0)
(0.000561150695717 -0.00237169082452 0)
(0.000418161686065 -0.00242219244307 0)
(0.000192893528165 -0.00170815806956 0)
(0.000271548560233 -0.00165376080144 0)
(0.000555903812517 -0.00156821992861 0)
(0.000878260357152 -0.00149274407716 0)
(0.00124069413369 -0.00155274221074 0)
(0.00114059527833 -0.00179157630011 0)
(0.000216169047513 -0.00744611032116 0)
(-0.00209988038241 -0.0127455221525 0)
(-0.00519939779178 -0.00919871126317 0)
(-0.00232439166967 -0.00348941124659 0)
(-0.00773644140615 -0.00885386942053 0)
(-0.00845759598759 -0.00916569388652 0)
(-0.00748870337862 -0.00712519373907 0)
(-0.00117295895916 -0.000471726299273 0)
(-0.00151474674968 -7.23267165669e-05 0)
(-0.00136613644484 -0.000644650105876 0)
(-0.00121544550185 -0.000910632394897 0)
(-0.000995459643156 -0.00103307520025 0)
(-0.000828426898493 -0.00111967600287 0)
(-0.000688200368444 -0.00118520595067 0)
(-0.000578208236068 -0.00125914581802 0)
(-0.000443393841993 -0.0012638418189 0)
(-0.000326985359785 -0.00128180266806 0)
(-0.000219495867816 -0.00129236546146 0)
(-0.000116485424706 -0.0013001446451 0)
(-1.51635625798e-05 -0.00130268965772 0)
(7.89462853757e-05 -0.00130630342664 0)
(0.000178145078277 -0.00136261702722 0)
(0.000222878407408 -0.0015304366329 0)
(0.000655577607171 -0.00189480660573 0)
(-0.00533031631251 -0.0665420054953 0)
(-0.0305411533143 -0.0262146910712 0)
(0.00606790469664 0.10986055485 0)
(0.0241965957565 0.257007755061 9.48448214786e-29)
(0.0425195229301 0.336659851513 0)
(0.0562440829121 0.377537048017 0)
(0.0675169600531 0.396305714417 0)
(0.0764632675868 0.403329753786 0)
(0.0840012649186 0.404567492968 5.32488598915e-29)
(0.0907065911323 0.403219142025 -5.26602747826e-29)
(0.0969706670837 0.400846304704 0)
(0.103009341312 0.398134346519 0)
(0.108930586816 0.395335117718 0)
(0.11477631995 0.392505010656 0)
(0.120553565556 0.389620058709 0)
(0.126253617256 0.386626407013 0)
(0.131856268036 0.383457599058 0)
(0.137336731613 0.380040560905 0)
(0.142658708236 0.376288399505 0)
(0.147780703878 0.372096997379 0)
(0.152639254398 0.367320219427 0)
(0.157154037579 0.361730780063 0)
(0.161173811895 0.354766745981 0)
(0.164341578159 0.345460654837 0)
(0.166084638222 0.332733135568 0)
(0.16574812791 0.315815653657 0)
(0.16276668233 0.29449363634 0)
(0.1567745974 0.269097455156 0)
(0.147636014516 0.240345816924 0)
(0.135418184058 0.209153049698 0)
(0.120346448852 0.176467444542 0)
(0.102728276027 0.143139787999 0)
(0.0829182601178 0.109921244905 0)
(0.0612551527367 0.07707787926 0)
(0.0376869662487 0.0454128464952 0)
(0.00891843989793 0.0151438200005 0)
(-6.59073411133e-05 -0.000764285344424 0)
(0.000475316990105 -0.00115154263497 0)
(0.000103859294573 -0.00137342887488 0)
(2.73768100831e-05 -0.00155049604407 0)
(1.0288782799e-05 -0.00163154670194 0)
(3.15604310317e-06 -0.00164032278766 0)
(9.74167721479e-05 -0.00161346357876 0)
(0.000257513081078 -0.00208239912667 0)
(0.000306337070452 -0.00263816155479 0)
(0.00028404447207 -0.00271577445244 0)
(0.000395657453551 -0.00246041812234 0)
(0.000708808133863 -0.00245999011459 0)
(0.000997397567919 -0.00278051629206 0)
(0.000468950290205 -0.00234194522681 0)
(0.000158516507466 -0.00203427627641 0)
(0.000126616092638 -0.00136820931758 0)
(0.000307698052202 -0.00125046009875 0)
(0.000625897335984 -0.00109919634292 0)
(0.00112976530649 -0.00147953348818 0)
(0.000375529755866 -0.00169471184137 0)
(-0.0040708131956 -0.0105117053138 0)
(-0.0050047906557 -0.0130948592969 0)
(-0.00670897601077 -0.0105526727234 0)
(-0.00772666462531 -0.00924604385965 0)
(-0.00926169861887 -0.00994622459919 0)
(-0.00735374730023 -0.00780717747398 0)
(-0.000713701747542 -0.000486715902686 0)
(-0.000769772335408 -0.000151633288027 0)
(-0.000820383681615 -0.00027487993629 0)
(-0.000892630172775 -0.000545036721955 0)
(-0.000821806920854 -0.000756783059874 0)
(-0.000714518790609 -0.000893867534417 0)
(-0.000598123132493 -0.00098170231902 0)
(-0.00050317496251 -0.00107844939789 0)
(-0.000385784257235 -0.00111454012899 0)
(-0.000281796552869 -0.00115384721504 0)
(-0.000184391245704 -0.00117341772722 0)
(-9.17838987542e-05 -0.00119485444547 0)
(2.16795633799e-06 -0.00120493531289 0)
(0.000100424965245 -0.0012067472172 0)
(0.000209721342682 -0.00121092242161 2.30727731269e-29)
(0.000347974193046 -0.00122295752408 -2.12589111456e-29)
(0.00056808206774 -0.00140184901973 0)
(0.000562578273807 -0.00179004039857 2.19800138983e-29)
(0.000371950542964 -0.077934001688 0)
(-0.0179791326654 -0.0367747549971 0)
(0.0145791407912 0.135983743265 0)
(0.0279166406213 0.275044346039 0)
(0.0453263023595 0.351811400673 0)
(0.0578363845092 0.389568332826 0)
(0.0678837189196 0.405787685145 0)
(0.0758192304633 0.411101405245 0)
(0.0826121202846 0.411333349364 0)
(0.088787878838 0.409453370948 0)
(0.0946774306078 0.406820743156 0)
(0.100440457101 0.403983689753 0)
(0.10614589479 0.401114390757 0)
(0.111810449352 0.398227357147 0)
(0.11742533738 0.395277703211 0)
(0.122972463808 0.392200712268 0)
(0.128424831955 0.388922669479 0)
(0.13375386827 0.385364007665 0)
(0.138918071164 0.381428500195 0)
(0.143873194844 0.376999795167 0)
(0.148547636566 0.371909047555 0)
(0.152854632409 0.365885951008 0)
(0.156616575848 0.358209118644 0)
(0.159394034874 0.347680833056 0)
(0.160512885677 0.333073612128 0)
(0.159254098564 0.313645840549 0)
(0.155051779666 0.28935685544 0)
(0.147594180605 0.260773931804 0)
(0.136830682422 0.228846038823 0)
(0.122924664534 0.194674580923 0)
(0.106200502827 0.159341710922 0)
(0.0870536713172 0.123757361018 0)
(0.0659385876836 0.088706723528 0)
(0.0431865778251 0.0539223340542 0)
(0.0178160702738 0.0206742273982 0)
(-0.000180466311628 -0.000938890969769 0)
(0.000106365046817 -0.00164921161435 0)
(0.000130926513106 -0.00143444885677 0)
(3.39993578545e-05 -0.0014927252376 0)
(-5.65202395194e-06 -0.00157506159658 0)
(-8.57811528547e-06 -0.00162402666171 0)
(-1.93367802397e-06 -0.00162200743333 0)
(0.000131204830488 -0.00134730517348 0)
(0.000381962521033 -0.00197878444007 0)
(0.000271272178055 -0.00257549367983 0)
(5.26569563985e-05 -0.00272994920673 0)
(0.000229149337534 -0.00215949123388 0)
(0.000642482379253 -0.00196688917469 0)
(0.00136726545837 -0.00254378999904 0)
(0.000880944416029 -0.00294572325522 0)
(-7.20799106247e-05 -0.00186331694198 0)
(9.83118086183e-05 -0.001668593518 0)
(0.000107834387199 -0.00088388668852 0)
(0.000386025059061 -0.000609681909572 0)
(0.000346751609894 -0.000908216608461 0)
(-0.00457964188786 -0.00810492426713 0)
(-0.00702497985876 -0.0124705852825 0)
(-0.00751335607388 -0.0136699794001 0)
(-0.00843198263557 -0.0114978390585 0)
(-0.00893301741351 -0.0097380434527 0)
(-0.00788238232725 -0.00838497864737 0)
(-0.000554974628798 -0.000683043791131 0)
(-0.000344489814907 -0.000308003524845 0)
(-0.000382246171791 -0.000268091780816 0)
(-0.000496411059532 -0.000369906587896 0)
(-0.00054005800329 -0.000541275649497 0)
(-0.000513830979694 -0.000686803378422 0)
(-0.000453102216503 -0.000795539014905 0)
(-0.000388003781151 -0.00089986175178 0)
(-0.000303391460641 -0.000962975362157 0)
(-0.000221152283071 -0.00102450598541 0)
(-0.000141212300505 -0.00106200351747 0)
(-6.4712292465e-05 -0.00109487286569 0)
(1.20612995062e-05 -0.00110889916993 0)
(9.10258136763e-05 -0.00111397353519 0)
(0.000180672762179 -0.00110436084973 0)
(0.000301045927255 -0.00107811729709 0)
(0.000501281020838 -0.00100902997425 2.17173600553e-29)
(0.000644182300214 -0.000984321216018 0)
(0.000580836966688 -0.00258983142845 -6.54736001279e-29)
(-0.00124907935222 -0.0814241617285 0)
(-0.00608917860557 -0.0362720746213 0)
(0.0196825689775 0.148939885693 0)
(0.0321223726894 0.29139684111 0)
(0.0480032409642 0.365597088513 0)
(0.0590665651569 0.400265511813 0)
(0.0679127531606 0.414152249775 0)
(0.0749140197527 0.418026205262 -5.10716681916e-29)
(0.0810433532972 0.417492650456 5.04861802987e-29)
(0.0867552456902 0.415260044573 0)
(0.0923165185725 0.412486540828 0)
(0.0978333270902 0.409597599488 0)
(0.103340542188 0.406701096475 0)
(0.108834215238 0.403781214793 0)
(0.114292996261 0.400779538558 0)
(0.119691536014 0.397624712981 0)
(0.124997081765 0.394237955897 0)
(0.130178237235 0.390534155324 0)
(0.135188031526 0.386407516726 0)
(0.139980244481 0.381728673757 0)
(0.144473569914 0.376302832887 0)
(0.148575438016 0.369808962757 0)
(0.152075701623 0.361320799574 0)
(0.154433367294 0.349372289739 0)
(0.154863606546 0.332603259745 0)
(0.15259213065 0.310357187126 0)
(0.147071951919 0.282829177151 0)
(0.138064087142 0.250863180193 0)
(0.125613088519 0.21565313254 0)
(0.10997637218 0.178486175675 0)
(0.0915714166603 0.140574895298 0)
(0.0708903407188 0.102888843962 0)
(0.0485106268479 0.0664849414252 0)
(0.0243636993653 0.0302805591705 0)
(-0.000146440560641 -0.000745622688852 0)
(-0.000121213500418 -0.00138280789855 0)
(-2.49559298902e-05 -0.00147287707959 0)
(-2.58187643386e-07 -0.00148078738058 0)
(-2.61938636741e-05 -0.00152988630953 0)
(-3.41910164791e-05 -0.00158059379301 0)
(-2.28966761299e-05 -0.00161261487048 0)
(-6.76478391329e-06 -0.00163118784014 0)
(0.000121995838821 -0.00100632275573 0)
(0.000468633410657 -0.00198646791219 0)
(0.000410672539545 -0.00315883076048 0)
(-0.000220218916818 -0.00252089992882 0)
(-5.5028009628e-05 -0.00174730141668 0)
(0.000500392609259 -0.0013103223013 0)
(0.000721194256337 -0.0013859996386 0)
(0.00346641159778 -0.0065257233844 0)
(0.000527667990911 -0.00141589024986 0)
(0.000125537064144 -0.00112319205562 0)
(-0.000172598527578 -0.000755371730991 0)
(2.71299392054e-05 -0.000544222099654 0)
(-0.00232886250214 -0.00699719015787 0)
(-0.00690018820145 -0.0107805157081 0)
(-0.0085398787745 -0.0135970458605 0)
(-0.00878984878838 -0.0139987795971 0)
(-0.00885600683256 -0.0117414172519 0)
(-0.00751103927837 -0.0084819434212 0)
(-0.000576053185134 -0.000883309579341 0)
(-0.000104254348218 -0.00046131752155 0)
(-0.000132045853186 -0.000317924060949 0)
(-0.000200002128201 -0.00035697669488 0)
(-0.000260372121235 -0.000437787229988 0)
(-0.000281935794691 -0.000540644349272 0)
(-0.000273855517228 -0.000652645563354 0)
(-0.000241942450029 -0.000749454249842 0)
(-0.000192940325556 -0.000822885117028 0)
(-0.000137647110015 -0.000898327668982 0)
(-7.81111225203e-05 -0.000951232238759 0)
(-2.01612803175e-05 -0.000998697654836 0)
(3.61018664058e-05 -0.00102194984165 0)
(9.08427964585e-05 -0.00104419749491 0)
(0.000145950813779 -0.00104835781636 0)
(0.000209619760938 -0.00102201312903 0)
(0.000293891562584 -0.000950594847358 0)
(0.000428513230979 -0.000792386031564 -2.32632973105e-29)
(0.00029504327911 -0.000557563705265 0)
(0.00218853891209 -0.0106688577582 0)
(-0.00247749292931 -0.0833056097179 0)
(0.00026923876679 -0.00178855365322 0)
(0.0221552822766 0.165263023658 0)
(0.034693598911 0.307288769294 0)
(0.0497508697701 0.378254775529 0)
(0.0595874394664 0.409777699686 0)
(0.0674138743264 0.421532407441 0)
(0.0736370580795 0.424223174852 0)
(0.0792265148556 0.423140253297 0)
(0.0845624691557 0.420706809642 0)
(0.089854818425 0.417888323542 0)
(0.0951636994396 0.415004162391 0)
(0.100496857636 0.412112631384 0)
(0.105835091311 0.409177595307 0)
(0.111148148538 0.406133039166 0)
(0.11640580859 0.402904090075 0)
(0.121570749098 0.399408375691 0)
(0.126609954057 0.395555688535 0)
(0.131470647842 0.391230063304 0)
(0.136105828538 0.386288052476 0)
(0.140422445977 0.38050502042 0)
(0.144323513182 0.373500044389 0)
(0.147558485407 0.364084053068 0)
(0.149462147563 0.350484958629 0)
(0.149132374164 0.33124147555 0)
(0.145753881199 0.305855585832 0)
(0.138822266826 0.274824754019 0)
(0.128192808401 0.239305183163 0)
(0.114015352217 0.200741601738 0)
(0.0966352001223 0.160581637723 0)
(0.0765321620013 0.120077844021 0)
(0.0541492578271 0.0800399886597 0)
(0.0298870427152 0.0422520923811 0)
(0.000318563692782 0.000269125980724 0)
(-0.000236379371134 -0.00110745218789 0)
(-9.14271367721e-05 -0.00130050234261 0)
(-6.97749926031e-05 -0.00143132728 0)
(-6.09035476551e-05 -0.00149047070755 0)
(-6.37001528468e-05 -0.00153838727221 0)
(-5.34712193522e-05 -0.00157647170432 0)
(-3.50042721513e-05 -0.00159956645196 2.46428750745e-29)
(-1.29388793524e-05 -0.00160887056562 0)
(0.000186188840947 -0.000639926992665 0)
(0.000271480619674 -0.000959572588516 0)
(-0.000356502132903 -0.00345580494849 0)
(-0.000832677712983 -0.00297882877327 0)
(-0.000266613248884 -0.00119620613796 0)
(0.000202455916147 -0.000775284258049 0)
(0.000289679117986 -0.000517269775711 0)
(0.00205790204739 -0.00375419253924 0)
(0.00290860128345 -0.00494135089111 0)
(0.00204008307055 -0.00393047178027 0)
(0.000703410765097 -0.00140432634072 0)
(-0.000258038664978 -0.00078243422983 0)
(-0.00584861442366 -0.0103035513417 0)
(-0.00807955663724 -0.0128750482653 0)
(-0.00893266556647 -0.0142151612066 0)
(-0.00856041696496 -0.0135700347929 0)
(-0.00721590584549 -0.0101402097192 0)
(-0.000743546890168 -0.00139671774752 0)
(-1.35024583629e-05 -0.000535321415274 0)
(1.48356607275e-07 -0.00036597077052 0)
(-1.33444329621e-05 -0.000382394350792 0)
(-5.3146576865e-05 -0.00040255429521 0)
(-8.29461809521e-05 -0.000463751692357 0)
(-9.45593950285e-05 -0.000545890809309 0)
(-8.85274658896e-05 -0.000633455138434 0)
(-6.59438059588e-05 -0.00070862358121 0)
(-3.32182538524e-05 -0.000787434397379 0)
(6.35459211227e-06 -0.000844047644923 0)
(4.78362163271e-05 -0.000905776226241 0)
(8.68562606757e-05 -0.000947209341801 0)
(0.000122455439203 -0.000985909581676 0)
(0.000150870902038 -0.00100477589925 0)
(0.000174608684962 -0.00101081040043 0)
(0.000193815539829 -0.000977533787558 0)
(0.000200721703413 -0.000907721685805 0)
(0.000173830413113 -0.000794151068288 0)
(-6.23201569897e-05 -0.000559473068998 0)
(0.000341356132588 -0.00163276970024 0)
(0.0111776396543 -0.0820909682327 0)
(0.000654400617332 -0.00146901885101 0)
(0.0213556152994 0.182351899537 0)
(0.0355289588166 0.322966657722 0)
(0.0503752560753 0.390015263387 0)
(0.0592919330184 0.418313748772 0)
(0.0663136943148 0.428110494515 0)
(0.0719349973693 0.429841998128 0)
(0.0771236644991 0.428389683901 0)
(0.0821812556489 0.425873202615 0)
(0.0872703696363 0.423078913033 0)
(0.0924145892321 0.420237648621 0)
(0.0976020588635 0.417371338399 0)
(0.10280385497 0.414431560738 0)
(0.107984593959 0.411349027058 0)
(0.113111656759 0.408047318702 0)
(0.118144423281 0.404441229889 0)
(0.123049659871 0.400435373461 0)
(0.127768317708 0.395902638148 0)
(0.132254298246 0.390684096958 0)
(0.136400101071 0.384520662434 0)
(0.140106760581 0.376960661689 0)
(0.143073252305 0.366478695174 0)
(0.144483475384 0.350962596521 0)
(0.14331524491 0.328901864591 0)
(0.138731795821 0.30004543144 0)
(0.130297697927 0.265262349799 0)
(0.117985316631 0.226054399788 0)
(0.102068884309 0.18413012986 0)
(0.0830266876868 0.141085985754 0)
(0.0614676939997 0.0980948226401 0)
(0.0374288035441 0.0553184928333 0)
(0.00727888702706 0.0152934097894 0)
(-0.000217951998649 -0.000931505865079 0)
(0.000197940904941 -0.00120883526276 0)
(-1.47882416423e-05 -0.00133206659826 0)
(-5.95690947355e-05 -0.00143444829689 0)
(-7.44317238128e-05 -0.0014964413215 0)
(-7.58159210566e-05 -0.00152775615193 0)
(-5.91317710432e-05 -0.00155207237202 0)
(-3.72118166175e-05 -0.00157782922264 -2.24889121373e-29)
(-1.47427826469e-05 -0.00158284997456 0)
(2.36267768907e-05 -0.000260198053098 0)
(3.56909109571e-05 -0.00352602451384 0)
(-0.00149877105161 -0.00519614043819 0)
(-0.00149726809764 -0.00420089469231 0)
(-0.000102597979569 -0.000529815323995 0)
(4.81599511263e-05 -0.000424113439949 0)
(0.000154711886449 -0.00028610614257 0)
(0.000384371179564 -0.000904656494275 0)
(0.00274107980694 -0.00505162239681 0)
(0.000386276398093 -0.000738395918109 0)
(0.000259624668866 -0.00273896094506 0)
(-0.00466371957659 -0.00799961721666 0)
(-0.00767297671559 -0.012771390635 0)
(-0.00881940319451 -0.0141515192496 0)
(-0.00874170499034 -0.0138743124785 0)
(-0.00724764202856 -0.0116980122926 0)
(-0.00280960319689 -0.00601908406772 0)
(8.29524561214e-05 -0.000473244824526 0)
(3.44130352962e-05 -0.000372500801564 0)
(8.9941020706e-05 -0.000397697768015 0)
(7.98797131626e-05 -0.000397235227665 0)
(6.55503470065e-05 -0.00043735554637 0)
(5.29159729988e-05 -0.000481750579073 0)
(5.13621122091e-05 -0.000545807039788 0)
(6.08684471105e-05 -0.000622030982102 0)
(7.9649819886e-05 -0.000688947385153 0)
(0.000105050824578 -0.000747699151263 0)
(0.000134956405951 -0.00081352969109 0)
(0.000162707186769 -0.000868060248717 0)
(0.000187192854163 -0.000922598698977 3.16035233201e-29)
(0.000201632832222 -0.000957532419815 0)
(0.000207482742363 -0.000996153312037 0)
(0.000200185667194 -0.00100929022952 0)
(0.000173509069462 -0.00097891477243 0)
(0.000134658267342 -0.00093407839143 0)
(0.000104562526958 -0.000813149893341 0)
(0.000256948006325 -0.00059839013334 0)
(-0.00020602777098 -0.000899724098386 -3.06644632945e-29)
(0.0149082200399 -0.0751646508791 3.01074833642e-28)
(0.00100514063393 -0.000269055653754 0)
(0.0246276968477 0.197977788351 0)
(0.0362177834142 0.337917280721 0)
(0.050146449023 0.400794203489 0)
(0.0582137951563 0.425984478656 0)
(0.0646069350182 0.43405336598 0)
(0.0697946030108 0.435035907123 0)
(0.0747226069172 0.433359807526 0)
(0.0796014485864 0.430843278324 0)
(0.084554313211 0.428114868117 0)
(0.0895784255792 0.425335543062 0)
(0.0946500390042 0.422502381201 0)
(0.0997359060257 0.419560651236 0)
(0.10479923272 0.41644051004 0)
(0.109807443418 0.413064834232 0)
(0.114717915419 0.409345640979 0)
(0.119498729161 0.405181720087 0)
(0.124083884051 0.400433487786 0)
(0.12843043421 0.394924758477 0)
(0.132412823764 0.38835664095 0)
(0.13593399022 0.380193908736 0)
(0.13862946859 0.368482003786 0)
(0.139501253207 0.350742954873 0)
(0.137409824986 0.325493324332 0)
(0.13152150861 0.292830432584 0)
(0.121495142923 0.2540612503 0)
(0.107432391494 0.21105586904 0)
(0.089736618491 0.16579407367 0)
(0.0690827667983 0.120038974617 0)
(0.0462778222826 0.0750640244165 0)
(0.0202611982192 0.0303226288317 0)
(-0.000316805049409 -0.000924061719288 0)
(-3.73366319088e-05 -0.00157360428496 0)
(1.33400788004e-05 -0.00137025167433 0)
(-3.6875136984e-05 -0.00140094802401 0)
(-6.10156259927e-05 -0.00145333642079 0)
(-6.73742890819e-05 -0.00149413223354 -1.93378038799e-29)
(-6.52441365624e-05 -0.00151289779935 0)
(-5.08843916338e-05 -0.00150578548361 0)
(-2.89634420514e-05 -0.00154766147785 0)
(-8.79795734633e-06 -0.00152651619866 0)
(1.05066858655e-05 -7.20627673687e-05 0)
(-0.000282067762111 -0.00416479189875 0)
(-0.00172522520861 -0.00488754745903 0)
(-0.000359675744721 -0.0012909214019 0)
(5.75957364488e-05 -0.00019638109303 0)
(0.000103896612846 -0.000241555168294 0)
(0.000207099640527 -0.000214240338574 0)
(0.000145575614658 -0.000366415683155 -4.21385181137e-29)
(0.00198703963483 -0.0050670281646 3.41781235396e-28)
(0.0011566373129 -0.00495940980614 0)
(-0.00213990811141 -0.00693992288037 0)
(-0.00601144009341 -0.0108527475125 0)
(-0.00830387848066 -0.0142398477058 0)
(-0.00923993858235 -0.0146030952223 0)
(-0.00849571028085 -0.0126849659231 0)
(-0.00550102708061 -0.00915814981002 0)
(0.000101760983985 -0.000511802695983 0)
(0.000221760061029 -0.000297191029513 0)
(0.000168547958274 -0.000353753463027 0)
(0.000174752239404 -0.000382653441002 0)
(0.000173793596561 -0.000416566668074 0)
(0.000166908546227 -0.000441175444376 0)
(0.000166268478402 -0.000481053338312 0)
(0.000172916488709 -0.000539732903319 0)
(0.000186753550116 -0.000603648254298 0)
(0.000205716886362 -0.000661922508401 0)
(0.000230845843729 -0.00072757792785 0)
(0.000252794184834 -0.000782782958983 0)
(0.000274810342126 -0.000849743149992 0)
(0.000287184489059 -0.000905743132777 -3.08687266074e-29)
(0.000290465383686 -0.000964655783415 0)
(0.000273688687174 -0.00101044712469 0)
(0.000229998905931 -0.00103899998354 0)
(0.000149712070786 -0.00105500477314 0)
(2.74152474869e-05 -0.00102102394733 0)
(-0.000127092410365 -0.000858053038121 0)
(-0.000165978272858 -0.000469792407248 0)
(-0.000673681759278 0.000369555340399 0)
(0.0144399621623 -0.0632375894689 0)
(0.00129446696892 0.000109765538703 0)
(0.0254778602286 0.21321835681 0)
(0.0360111869949 0.352043385387 0)
(0.0488807667071 0.410584689422 0)
(0.0562589574932 0.432933086075 0)
(0.0622713183572 0.439552712061 0)
(0.0672196701988 0.439972151196 0)
(0.0720323095951 0.438174798708 0)
(0.076831447488 0.435702495282 0)
(0.081712470658 0.433052987331 0)
(0.0866585423055 0.430335438414 0)
(0.0916424381371 0.427531198568 0)
(0.096631935036 0.424582900374 0)
(0.10159243338 0.421421196669 0)
(0.106493679232 0.417967969078 0)
(0.111292291864 0.414131835559 0)
(0.115959215016 0.409804540963 0)
(0.12042052806 0.404832403442 0)
(0.12463930657 0.39901976331 0)
(0.128467158344 0.392021863062 0)
(0.131814733914 0.383204905249 0)
(0.134237467998 0.370068607261 0)
(0.134519854365 0.349758324909 0)
(0.131415699459 0.320922556962 0)
(0.124125293407 0.284119354752 0)
(0.112428231095 0.241153534684 0)
(0.0965644720381 0.194264030118 0)
(0.0770431928209 0.145647238471 0)
(0.0545770830461 0.0970996699949 0)
(0.0297305015235 0.0501836222814 0)
(0.000196827044014 0.000296742569576 0)
(-0.0002982624516 -0.00123199084167 0)
(-6.94248786829e-05 -0.00135625542332 0)
(-2.706627603e-05 -0.00137497260613 0)
(-4.05607435868e-05 -0.00141759598102 0)
(-4.99693561124e-05 -0.00145858647178 -1.78533940868e-29)
(-4.93439503402e-05 -0.00148967095601 1.84103134314e-29)
(-4.31793944407e-05 -0.00151027668368 0)
(-3.51117913905e-05 -0.00149423448613 0)
(-1.86604587375e-05 -0.0015200587465 0)
(-2.83297841485e-06 -0.0015321849858 0)
(2.48171053486e-06 -0.00015384852008 0)
(-0.000396459785941 -0.00484068594286 0)
(-0.00121106561057 -0.00490107077921 0)
(1.61039935116e-06 -0.000372433406132 0)
(6.03131934158e-05 -0.0001612476397 0)
(9.65471882012e-05 -0.000173344417741 0)
(0.000132398327231 -0.00015542837848 0)
(2.52225262455e-05 -0.000129917287531 0)
(0.00126450335567 -0.00456418822513 0)
(0.00104989425821 -0.00705084399519 0)
(-0.00290728496353 -0.0100408455376 0)
(-0.00609818715912 -0.0134966501705 0)
(-0.00822154042055 -0.0157694900468 0)
(-0.00931798842519 -0.0151402141772 0)
(-0.00777552412208 -0.0109551697344 0)
(-0.000157777386188 -0.00100600922327 0)
(0.000325114362439 -0.000392996168487 0)
(0.000245107036335 -0.000336668160864 0)
(0.000228933472384 -0.000343483211934 0)
(0.000245390691847 -0.000388669824388 0)
(0.000249725955177 -0.00041027510638 0)
(0.000257654103472 -0.00044073507335 0)
(0.000264078721134 -0.000476251585432 0)
(0.000278115220305 -0.000526651650703 0)
(0.000299418784176 -0.000586993207694 0)
(0.000322203734335 -0.000642917389502 4.13093803492e-29)
(0.000345145689731 -0.000697740233955 0)
(0.000370623091447 -0.000766653777156 0)
(0.000387572242175 -0.000832404542623 0)
(0.000400480164889 -0.000907386104177 0)
(0.000392376887365 -0.000969799414874 0)
(0.000362533840948 -0.00104867472472 0)
(0.000285364725048 -0.0011251334152 0)
(0.00014641481413 -0.00120159257536 0)
(-8.68584889667e-05 -0.00123979718106 0)
(-0.000467402359774 -0.00117713537348 0)
(-0.00108501643196 -0.000733283063829 0)
(-0.00124380529321 0.000586725975024 0)
(0.0118940176513 -0.0481230458346 0)
(0.00149803586229 0.000300407778629 0)
(0.0231638894238 0.227213463902 -9.92711044949e-29)
(0.0343297862399 0.365435984103 6.19272214521e-29)
(0.0463666801513 0.419672464791 0)
(0.0533609299009 0.439462080506 0)
(0.0593224242304 0.444868141375 0)
(0.0642535055779 0.444840887581 0)
(0.0690937003237 0.442961773564 0)
(0.0739033760764 0.440532535395 0)
(0.0787677608322 0.437945234277 0)
(0.0836702077707 0.435270846433 0)
(0.0885889341532 0.432480272154 0)
(0.0934978365603 0.429514440982 0)
(0.0983677745998 0.426303780046 0)
(0.10317269533 0.422767766348 0)
(0.107869539632 0.418810362692 0)
(0.112433510907 0.41431447438 0)
(0.116781443587 0.409110491014 0)
(0.120885945251 0.402980559342 0)
(0.124569514816 0.395527386128 0)
(0.127758807053 0.386001061168 0)
(0.129907718906 0.371209976351 0)
(0.129542734396 0.347935545114 0)
(0.125331718643 0.315095666045 0)
(0.11654531713 0.273830466816 0)
(0.103115101157 0.226496062245 0)
(0.0854607238589 0.17567974406 0)
(0.0642622321659 0.123728903108 0)
(0.0400466170454 0.072469160101 0)
(0.00972495134909 0.0238051940391 0)
(-0.0002775404896 -0.000879234260985 0)
(0.000205673086021 -0.00125385297533 0)
(1.86117661692e-05 -0.00134685021297 0)
(-9.81079806036e-06 -0.0013897768857 -1.62790210733e-29)
(-2.93642763298e-05 -0.00142937295216 0)
(-3.6489196611e-05 -0.00146204003977 1.72636938859e-29)
(-3.50911328076e-05 -0.0014873277992 0)
(-2.8303604208e-05 -0.00150637685538 0)
(-2.22993818997e-05 -0.00150220529852 0)
(-1.43651683968e-05 -0.00151434164226 0)
(-3.92048335658e-06 -0.00153379771323 0)
(-9.82440325781e-05 -0.000249114552604 0)
(-0.00134654052102 -0.00519989996814 0)
(-0.000710546482587 -0.00456671970146 0)
(5.76176650964e-05 -0.000124941497258 0)
(6.52556747653e-05 -0.000122240335559 0)
(8.85421014052e-05 -0.000151445244575 0)
(7.9780100302e-05 -0.00017357343092 0)
(-4.52843619249e-05 -0.000216554620615 0)
(0.000299678078349 -0.00148697356405 0)
(0.00138561186874 -0.00927042247551 0)
(-0.00272530862964 -0.0130240519439 0)
(-0.00510869649638 -0.0157850613929 0)
(-0.0066762639012 -0.0167491525352 0)
(-0.00758212788064 -0.014089022773 0)
(-0.000783632682131 -0.00186377064108 0)
(0.000215362503789 -0.000616008724422 0)
(0.000252714496487 -0.000412541505056 0)
(0.000272119922579 -0.000358911390535 0)
(0.000283108655886 -0.000352502814309 0)
(0.000296210060067 -0.000366903108499 0)
(0.000310804504869 -0.000389353835257 0)
(0.000336645919195 -0.000430358962335 0)
(0.000351237445698 -0.000462264701679 0)
(0.000373154553269 -0.000506929203579 0)
(0.000400753849764 -0.000560087165833 0)
(0.000428867514879 -0.000613211867974 -4.00611496001e-29)
(0.000460162787784 -0.00067645185602 0)
(0.000484126892739 -0.000739538207995 0)
(0.00051283127753 -0.000822609319625 0)
(0.00052340009551 -0.000894803742857 0)
(0.000515924569905 -0.000980879102373 0)
(0.000482865010823 -0.0011017589189 0)
(0.000397459836375 -0.00124575935671 0)
(0.000222511227876 -0.00141526113011 0)
(-0.000104739923017 -0.00165577787165 0)
(-0.000697536065456 -0.00191508715618 0)
(-0.00216024935596 -0.00206367179792 0)
(-0.00212961927592 -0.00186966597754 0)
(0.00754540361386 -0.0332265305736 0)
(0.00175874729062 -0.00178293201305 0)
(0.0169829771134 0.240133178621 0)
(0.0307045182364 0.378743037966 0)
(0.042605750901 0.428690134737 0)
(0.0496251803003 0.446027300668 0)
(0.055881364386 0.450302534633 0)
(0.061008537141 0.44983208146 0)
(0.0659924197867 0.447833679539 0)
(0.0708776366535 0.445399222443 0)
(0.0757610237968 0.442830368099 0)
(0.0806399893331 0.440165480655 0)
(0.0855061456009 0.43736524829 0)
(0.0903435681643 0.434366890542 0)
(0.0951310194918 0.431098191335 0)
(0.0998477680032 0.427473838179 0)
(0.104451843881 0.423391374911 0)
(0.108923730682 0.418722565668 0)
(0.113169316091 0.413279982869 0)
(0.117174866166 0.406820266988 0)
(0.120725674496 0.398886496534 0)
(0.12377578202 0.388592171849 0)
(0.125650008591 0.371873280188 0)
(0.124570972372 0.345194918992 0)
(0.119153250046 0.307917869923 0)
(0.10877752601 0.261891289556 0)
(0.0935615046199 0.210060942797 0)
(0.0741342866808 0.155299350679 0)
(0.0511872524214 0.100097536952 0)
(0.0247462746512 0.0468028939401 0)
(-0.00012241529306 -0.000322799111551 0)
(-0.000168652054488 -0.00163426522796 0)
(2.48287614474e-05 -0.00137895188188 0)
(4.33034699068e-06 -0.00139347230804 0)
(-1.0484107389e-05 -0.00141252471381 1.59664551475e-29)
(-2.29623381283e-05 -0.00143990104867 1.59140869472e-29)
(-2.81557515196e-05 -0.00146419566331 0)
(-2.74602318191e-05 -0.00148393914314 0)
(-2.22561625159e-05 -0.0014990468827 0)
(-1.66715372316e-05 -0.00149486426441 0)
(-1.30174480232e-05 -0.0015077084154 0)
(-5.60071306894e-06 -0.00152428826376 0)
(-0.00101647946738 -0.0024188907666 0)
(-0.00190491579685 -0.0053814949149 0)
(-0.000604412689778 -0.00376737011532 0)
(9.59435196159e-05 -9.03364983761e-05 0)
(0.000113986327465 -0.000106752083438 0)
(0.000111123656714 -0.00014341602758 0)
(0.0001142390426 -0.00019504626982 0)
(0.000100910235432 -0.000298065165352 0)
(0.000184135498114 -0.00101004773186 0)
(0.0011012458944 -0.0114890310884 0)
(-0.00232540705446 -0.0154907470257 0)
(-0.00386840058 -0.0174534265701 0)
(-0.00457638111984 -0.0171315066515 0)
(-0.00390873333988 -0.0131682101788 0)
(9.07706409039e-06 -0.000620032838564 0)
(-1.42697471035e-05 -0.000469086726276 0)
(0.000218966785231 -0.000324334738572 0)
(0.00030285825273 -0.000328973256609 0)
(0.000334069166378 -0.000334780328809 0)
(0.000360992625163 -0.000356808749111 0)
(0.000378850732278 -0.000375623814171 0)
(0.000403782384023 -0.000404077199661 0)
(0.000432305247201 -0.000439482760438 -5.31174663677e-29)
(0.000461288260977 -0.000479603743623 0)
(0.000496473528878 -0.000528751317097 0)
(0.000533113485613 -0.000582685535224 0)
(0.000566661168855 -0.000640694546884 0)
(0.000609116971495 -0.000718553410768 0)
(0.000636216369469 -0.000788482390286 0)
(0.000655995191399 -0.000872633647153 0)
(0.000672263240907 -0.000998716554274 0)
(0.000654362648105 -0.00114677836271 0)
(0.000599031554895 -0.0013468851811 0)
(0.000469811977848 -0.00161846654585 0)
(0.000218874084746 -0.00199359710835 0)
(-0.000228711619546 -0.00249246211694 0)
(-0.00105875069103 -0.00317186071856 0)
(-0.00297790066708 -0.00447659827527 0)
(0.000440382925177 -0.00712293970012 0)
(0.00264551999634 -0.00527681772639 0)
(0.00612962741079 0.254691474391 0)
(0.0249417793481 0.392603714523 0)
(0.0380463541838 0.43834215806 0)
(0.0454749916093 0.453096121952 0)
(0.0522323600204 0.456113390052 0)
(0.0576819600114 0.455080956456 0)
(0.0628608192012 0.452857731669 0)
(0.067840257462 0.450334453552 0)
(0.072747019549 0.447723433546 0)
(0.0776019186559 0.445027047489 0)
(0.0824144678605 0.442191213042 0)
(0.0871806942796 0.439145081819 0)
(0.0918882499128 0.435810202813 0)
(0.0965216995205 0.432093516061 0)
(0.101040506081 0.427884130494 0)
(0.10543083935 0.423040012681 0)
(0.109585644451 0.417354169932 0)
(0.113509501127 0.410553714996 0)
(0.116940287513 0.402114870679 0)
(0.119874582668 0.390990554512 0)
(0.121472910377 0.372019816339 0)
(0.119601925215 0.341448296195 0)
(0.112869505336 0.299292045076 0)
(0.100813057043 0.248236768004 0)
(0.0837902664669 0.191827510062 0)
(0.0626381826213 0.133114349338 0)
(0.0376185392652 0.07490967296 0)
(0.00731481978155 0.0204448501923 0)
(-0.000273997247007 -0.00102389872103 0)
(0.000147732384727 -0.00134513742115 0)
(5.51824926095e-05 -0.00137361262186 0)
(1.67961981732e-05 -0.00140460288149 0)
(-5.28438558053e-06 -0.00142503426294 0)
(-1.83228754166e-05 -0.00144623336241 -1.55246264605e-29)
(-2.38718231189e-05 -0.00146458059079 0)
(-2.41786936069e-05 -0.00147958252103 -1.55381998089e-29)
(-1.96946593541e-05 -0.00149062030994 0)
(-1.51481857526e-05 -0.00148914743449 0)
(-1.32968882368e-05 -0.00150206620471 0)
(-6.15209252847e-06 -0.00150742070202 0)
(-0.000723946781247 -0.00332860318069 0)
(-0.00196286058368 -0.00526509484454 0)
(-4.06178904268e-06 -0.000418734046722 0)
(0.0001491882184 -0.000124856917252 0)
(0.000135100309535 -0.000117700204444 0)
(0.000139805836174 -0.000142837940756 0)
(0.000145130029413 -0.000182355717722 0)
(0.000170570705287 -0.000262034066735 0)
(0.000160431261587 -0.000623972217845 0)
(0.000741072281996 -0.0130772670274 0)
(-0.00194655955087 -0.0172774444637 0)
(-0.00293958639833 -0.0184717352854 0)
(-0.00327087450584 -0.0168048588318 0)
(-0.00145282894861 -0.0102196717754 0)
(0.000694875610162 0.000203222900881 0)
(0.000182192416291 -0.000177258804421 0)
(0.000304405890344 -0.000247851392478 0)
(0.000345906753865 -0.000278977227952 0)
(0.000377627877587 -0.000302279810376 0)
(0.000411362057962 -0.000327276989996 0)
(0.000437418260089 -0.000347996246417 0)
(0.000471069396961 -0.000376569174065 0)
(0.000504616372159 -0.000406865031866 5.20398255649e-29)
(0.000542910264471 -0.000444257671265 0)
(0.000586123869284 -0.000489938926799 0)
(0.000626091199342 -0.000539217274804 0)
(0.000677167578229 -0.000603911014897 0)
(0.000719691750312 -0.000667907786017 0)
(0.000763703934421 -0.000746178302009 0)
(0.000812498582204 -0.000851770916851 0)
(0.000849482896454 -0.00098084217211 0)
(0.000877940354888 -0.00115608947171 0)
(0.000869600065277 -0.00137108314397 0)
(0.00085693327722 -0.00172523687231 0)
(0.000796205592421 -0.00221921188345 0)
(0.000677198828821 -0.00294872560703 0)
(0.000462833789835 -0.00408477063109 0)
(2.07307239965e-05 -0.00596106413357 0)
(0.00084115625827 -0.0098870656902 0)
(-0.00031821539606 -0.00553814122088 0)
(-0.000864810809201 0.270666302828 0)
(0.0185494261388 0.407211315557 0)
(0.0335448976851 0.449002928627 0)
(0.0415866709668 0.460902917275 0)
(0.0487974978877 0.462383704593 0)
(0.0545312751834 0.460599953529 0)
(0.0598566307628 0.458021067864 0)
(0.0648869897311 0.455319498453 0)
(0.0697831424955 0.452607643509 0)
(0.0745896714666 0.449843227132 0)
(0.0793327335133 0.446950652602 0)
(0.0840187386728 0.44384599687 0)
(0.0886433319911 0.440440857108 0)
(0.093195008356 0.43663155729 0)
(0.0976346187039 0.432296862592 0)
(0.101953613747 0.427278155323 0)
(0.106029953268 0.421347489933 0)
(0.109891530216 0.414197577135 0)
(0.113216331086 0.405230869601 0)
(0.116063230159 0.393211433008 0)
(0.117383794669 0.371603645424 0)
(0.11462845407 0.336598075798 0)
(0.106461170498 0.28911799233 0)
(0.0926358290974 0.232800990937 0)
(0.0738073884114 0.171763020131 0)
(0.0508327656226 0.109158863114 0)
(0.0231346562111 0.0486773715959 0)
(-0.000150312876352 -0.000429495079962 0)
(-0.000112523665723 -0.00148908411105 0)
(3.9572320384e-06 -0.00140578666127 0)
(6.51688725432e-06 -0.00141255519644 0)
(-2.71168996782e-06 -0.0014240092524 0)
(-1.28829234054e-05 -0.00143756122657 0)
(-2.08386521955e-05 -0.00145165530979 0)
(-2.44559942634e-05 -0.00146454670739 0)
(-2.47538802356e-05 -0.00147484698841 1.52972483824e-29)
(-2.09138615144e-05 -0.00148174148264 0)
(-1.6561087539e-05 -0.0014858675793 -1.51552092671e-29)
(-1.39373731093e-05 -0.00149612705636 0)
(-6.14107625043e-06 -0.00149475159174 0)
(-1.68551463136e-05 -0.00392204934092 0)
(-0.000151165257989 -0.00565398404739 0)
(7.5787846305e-05 -0.000343984799663 0)
(4.40289874772e-05 -6.7831362026e-05 0)
(0.000136507372806 -9.37666721676e-05 0)
(0.000165514407176 -0.000129711579686 0)
(0.000180400842481 -0.000174236031872 0)
(0.000197732012078 -0.000229342286392 0)
(0.000138085379708 -0.000447580192843 0)
(0.000460313432197 -0.0142139289805 0)
(-0.00166457593458 -0.0185809218401 0)
(-0.00249626043331 -0.0191790651373 0)
(-0.00299035096468 -0.0164632123044 0)
(-0.000369853462307 -0.00865069391982 0)
(0.000337521239691 -0.000101713237743 0)
(0.000325571404067 -0.000164989125219 0)
(0.000380163320417 -0.000221556895937 0)
(0.000387625834196 -0.000245512275587 0)
(0.000415980888266 -0.000266448277324 0)
(0.000458104765068 -0.00029408080755 7.15419465584e-29)
(0.000495308648577 -0.000320106972983 0)
(0.000531838436891 -0.000342141440771 0)
(0.000568049031595 -0.000364922319363 0)
(0.000618853700897 -0.000401572048555 0)
(0.000663684818861 -0.000441528603809 0)
(0.000718043485582 -0.000490847713821 0)
(0.000775016647604 -0.000547163911931 0)
(0.000835745590829 -0.000614868057087 0)
(0.000900186657995 -0.000694285471438 0)
(0.000968596646378 -0.000793937468063 0)
(0.00104667649448 -0.000930647121065 0)
(0.00109560461826 -0.0010885990733 0)
(0.00119955084366 -0.00136074559328 0)
(0.00129504186311 -0.00170809578228 0)
(0.00143305253058 -0.0021951500871 0)
(0.00164483718661 -0.00290830381154 0)
(0.00197121684488 -0.00399495388174 0)
(0.00281593837926 -0.0060110110797 0)
(3.14089020912e-06 -0.00702588675715 0)
(-0.047702390569 -0.00586432485076 0)
(0.00108299616271 0.296888517515 0)
(0.0137973412702 0.423436277103 0)
(0.0300885978734 0.460455327315 0)
(0.0386705267507 0.469196643578 0)
(0.0460146353352 0.468911782613 0)
(0.0517999574275 0.466239122015 0)
(0.0571157584841 0.463218370894 0)
(0.0620946229332 0.460282561933 0)
(0.0669123538441 0.457435045361 0)
(0.0716262806258 0.454582935548 0)
(0.0762718607932 0.451624563802 0)
(0.0808611403937 0.44845958758 0)
(0.0853952286761 0.444987039346 0)
(0.0898640584779 0.441090555617 0)
(0.094229705699 0.436637087076 0)
(0.0984875735537 0.431448745172 0)
(0.102498996543 0.425275766749 0)
(0.106320150873 0.417770532948 0)
(0.10955444425 0.408255711078 0)
(0.112348315672 0.395272948306 0)
(0.113388232145 0.370569575009 0)
(0.109637909538 0.330537960918 0)
(0.0999045746308 0.277298433133 0)
(0.0842361546127 0.215517720319 0)
(0.063572605252 0.149817221883 0)
(0.0383699025564 0.0835386159329 0)
(0.00748504317983 0.0220296179422 0)
(-0.000312085318843 -0.00120858165765 0)
(0.00011297447652 -0.00139385525261 0)
(1.30066775447e-05 -0.00140943222577 0)
(-6.96591057982e-06 -0.00142249516041 0)
(-1.72789661972e-05 -0.00143226003788 0)
(-2.42131075769e-05 -0.00144615337045 0)
(-2.8714260645e-05 -0.0014564851813 0)
(-2.99524435589e-05 -0.00146617114742 0)
(-2.85280587175e-05 -0.00147378771968 0)
(-2.54169156532e-05 -0.00147372760094 0)
(-2.16870048319e-05 -0.00147985011626 1.5261769689e-29)
(-1.66950363087e-05 -0.00149181717203 0)
(-6.77933382263e-06 -0.00148404034311 0)
(0.000243480918215 -0.00381752081847 0)
(0.000618081420022 -0.00516796930872 0)
(0.00085495846141 -0.00149460033947 0)
(0.000100740777487 9.81701650462e-06 0)
(0.000194086237621 -5.87142919546e-05 0)
(0.000206280349899 -0.00011138912784 0)
(0.000216693301169 -0.000162164213435 0)
(0.000227234958488 -0.000223816974061 0)
(0.000139154748512 -0.000438514667344 0)
(0.000293900263007 -0.0150950218233 0)
(-0.00134081732172 -0.0196277194612 0)
(-0.0020580394309 -0.0198293921966 0)
(-0.00318269242165 -0.0160456128225 0)
(0.000108856460376 -0.00245499659742 0)
(0.000535926094178 -0.000318348129535 0)
(0.000458026692736 -0.000219579703607 0)
(0.000406198800153 -0.000194409279792 0)
(0.000433080022716 -0.000219406484299 0)
(0.000477921558513 -0.000247150402591 0)
(0.000495400720565 -0.000258379705368 -6.93037741796e-29)
(0.000529605034341 -0.000274172245838 0)
(0.00058023349284 -0.000295642175777 0)
(0.00063524934767 -0.000323393491533 0)
(0.000680705332915 -0.00035146257092 0)
(0.000732728117384 -0.00038424047096 0)
(0.000804876917375 -0.000431642796079 0)
(0.000871755656241 -0.000485069752176 0)
(0.00094112816743 -0.000542463141025 0)
(0.00102450770778 -0.00061515801454 0)
(0.00112644946286 -0.000713936441597 0)
(0.00120831219137 -0.000828689126983 0)
(0.00133581607511 -0.00100533692345 0)
(0.00148976271044 -0.00123019432166 0)
(0.00169131438324 -0.00152482260668 0)
(0.00199643465307 -0.00191330093612 0)
(0.00247709378958 -0.00243809008783 0)
(0.00356592616832 -0.00314114930597 0)
(0.00292776538605 -0.00445295725724 0)
(0.000927888062774 -0.0573775640684 0)
(-0.0345212785933 0.0144106918611 0)
(0.006255179157 0.324440049117 0)
(0.014643508659 0.438884378243 0)
(0.0291823298979 0.471515953703 0)
(0.0372256979726 0.477226482207 0)
(0.0441147399103 0.475252444479 0)
(0.0496016997847 0.471730596091 0)
(0.054695244389 0.468283830933 0)
(0.0594918602054 0.465118894912 0)
(0.0641477747176 0.462138690733 0)
(0.0687155729709 0.459203597401 0)
(0.0732298000995 0.456186796592 0)
(0.0777020805634 0.452971386268 0)
(0.0821358587468 0.449443075536 0)
(0.0865195206 0.44547196815 0)
(0.0908165539809 0.440912308546 0)
(0.0950240376409 0.43556451415 0)
(0.0989861113333 0.429156678207 0)
(0.102791529303 0.42129357797 0)
(0.105952636948 0.411213508624 0)
(0.108734665502 0.397195021376 0)
(0.10948756131 0.368847227142 0)
(0.10460518086 0.323146064489 0)
(0.0931700112038 0.263734687848 0)
(0.0756151185174 0.196341692443 0)
(0.0529223923603 0.126067398263 0)
(0.0247300566329 0.0564733216184 0)
(-0.000175411410802 -0.000390475141679 0)
(-0.000193879522956 -0.0015793109685 0)
(-3.13707952587e-05 -0.00144148240694 0)
(-3.21783205944e-05 -0.0014379742008 0)
(-3.63115828388e-05 -0.00143356071091 0)
(-4.04792967347e-05 -0.00144186059367 0)
(-4.33573619287e-05 -0.0014527230015 0)
(-4.49471240589e-05 -0.00146068773298 0)
(-4.37264064786e-05 -0.00146837608098 0)
(-3.96367845729e-05 -0.00147540069491 0)
(-3.45312063983e-05 -0.00148141656438 0)
(-2.74823333388e-05 -0.00148327863212 0)
(-1.74410858712e-05 -0.00148729546046 0)
(-5.93829457896e-06 -0.00147115676084 0)
(0.000195090002935 -0.00329612283516 0)
(0.000766364211153 -0.00446671280363 0)
(0.000790954616844 -0.0020101868913 0)
(0.000136151584262 -2.49216309987e-06 0)
(0.000249077361212 -5.06426874843e-05 0)
(0.000247557992378 -0.000101336975619 0)
(0.000254651427952 -0.000153766412118 0)
(0.000256116107675 -0.000229446261392 0)
(0.000159096292303 -0.000587679122571 0)
(0.0002354720816 -0.0157180063369 0)
(-0.000870738156387 -0.0204374080871 0)
(-0.00122415789156 -0.0204304723937 0)
(-0.00209136597537 -0.0161722206972 0)
(0.000286055299979 -0.00156374207186 0)
(0.000396930180532 -0.00036220392735 0)
(0.00048384199322 -0.000252288847267 0)
(0.000467378001828 -0.000211204950078 0)
(0.000472147226699 -0.000197843211393 0)
(0.000505416191577 -0.000211317839092 0)
(0.000525383967301 -0.000221469665744 0)
(0.000589037143187 -0.000240386879698 0)
(0.000627403777323 -0.000249751466634 0)
(0.000669756938685 -0.000266523324655 0)
(0.000726813982565 -0.00029018689941 0)
(0.000808161347639 -0.000323113500121 0)
(0.000872590198321 -0.00035968290569 0)
(0.000946005465298 -0.000404550352333 0)
(0.00104133595446 -0.000458999177586 0)
(0.0011402051287 -0.000522525876494 0)
(0.00124548535897 -0.000601975716958 0)
(0.00134232551403 -0.000698894347748 0)
(0.00152760896551 -0.000855496960564 0)
(0.00171908469312 -0.00103296192743 0)
(0.00197813352909 -0.00124681914816 0)
(0.00234626971473 -0.00149436171017 0)
(0.00287247065319 -0.00175823754427 0)
(0.00395030418962 -0.00197116724441 0)
(0.00271236118316 -0.00199595075829 0)
(0.00859168870063 -0.0730410251411 0)
(-0.00907019492481 -0.0436448757433 0)
(0.0125259716681 0.341320308325 0)
(0.0190841050795 0.451566092381 0)
(0.0304588505921 0.480935762786 0)
(0.0370031309751 0.484231001698 0)
(0.0429554421556 0.480962665817 0)
(0.0478602857112 0.476811526379 0)
(0.0525511439892 0.473054436094 0)
(0.0570500823972 0.469724163509 0)
(0.0614681006908 0.466650767381 0)
(0.0658395067571 0.463661301395 0)
(0.0701897567699 0.460609886392 0)
(0.0745251565314 0.457365924794 0)
(0.0788489967476 0.453802790725 0)
(0.0831454112097 0.449777427032 0)
(0.0873803351238 0.445130951887 0)
(0.0915493286498 0.439640024791 0)
(0.0954807189619 0.433010650978 0)
(0.0992985612431 0.424791059048 0)
(0.102407168482 0.414132356023 0)
(0.105227665842 0.398999439948 0)
(0.105681101267 0.366344628051 0)
(0.0994901539996 0.314266388701 0)
(0.0861981817212 0.248263487674 0)
(0.0666865266775 0.175134889436 0)
(0.041606272809 0.100874873129 0)
(0.00977098128356 0.0293265110032 0)
(-0.000438602052365 -0.00121921698529 0)
(3.06824078482e-05 -0.00140722252841 0)
(-4.81813348701e-05 -0.0014244169716 0)
(-6.19324200095e-05 -0.00143638476913 0)
(-6.86876902411e-05 -0.00143936693158 0)
(-7.17780351757e-05 -0.00144186653994 0)
(-7.24082145435e-05 -0.00145521460584 0)
(-7.06071095562e-05 -0.00146086216611 0)
(-6.59689584575e-05 -0.00146533117009 0)
(-5.84206117775e-05 -0.00146875950317 0)
(-4.80404579127e-05 -0.00147090309918 0)
(-3.37258799792e-05 -0.0014687128345 0)
(-1.68533310563e-05 -0.00147494114574 0)
(-4.031593748e-06 -0.00146130771011 0)
(4.82595545631e-05 -0.00285872017394 0)
(0.000735397422305 -0.00386272995957 0)
(0.000796667867718 -0.00263628870881 0)
(0.000159552148689 -3.08890071066e-05 0)
(0.000287370500709 -5.12637988314e-05 0)
(0.000284388271642 -9.36074747979e-05 0)
(0.000297689833168 -0.000139085173281 0)
(0.000325065151653 -0.00021483928511 0)
(0.000130374218555 -0.000498223996841 0)
(-1.83127356125e-05 -0.0159103414367 0)
(-0.000358981097696 -0.0208888595641 0)
(-0.000370619785893 -0.0208038068602 0)
(-0.000778033540265 -0.0160498538497 0)
(0.000341379817736 -0.000484768722301 -3.52356020396e-28)
(0.00040526111635 -0.000223749789165 0)
(0.000503418359762 -0.00021425153934 0)
(0.000541721893924 -0.000216925529533 0)
(0.000531919599408 -0.000197243986945 0)
(0.000529306231088 -0.000184315579873 0)
(0.000569923947942 -0.00018813061368 0)
(0.000610059574477 -0.000191336915378 0)
(0.000649912361947 -0.000198113550018 0)
(0.000702148522193 -0.000207424295373 0)
(0.000791348667345 -0.000225418135945 0)
(0.000854686800989 -0.000246863589147 0)
(0.000928333348284 -0.000282000270994 0)
(0.00102349742846 -0.000320065897979 0)
(0.00112037417672 -0.000358438898406 0)
(0.00122687105777 -0.000408826026054 0)
(0.00135058474521 -0.000479223420531 0)
(0.00147556321604 -0.000559973173228 0)
(0.00167023476737 -0.000673469858332 0)
(0.00188108022122 -0.000801054976656 0)
(0.0021526991758 -0.00093772280873 0)
(0.00250781696223 -0.00106755445864 0)
(0.00295382447962 -0.00115142352309 0)
(0.00375777849061 -0.00110609638854 0)
(0.00217973672562 -0.000734495023967 0)
(0.00835352522945 -0.071035880488 0)
(9.60824322503e-05 -0.000852639642411 0)
(0.0177324911425 0.349383751937 0)
(0.0237464686298 0.461450063133 0)
(0.0324904046675 0.488326885102 0)
(0.037326823708 0.489886069608 0)
(0.0421821962071 0.485811525982 0)
(0.0463822827294 0.481322227388 0)
(0.0505715930861 0.477418832171 0)
(0.0546990024696 0.474020434938 0)
(0.0588251112724 0.470917124258 0)
(0.0629617617281 0.467919209719 0)
(0.0671218193513 0.464870027156 0)
(0.0713039737192 0.461629702525 0)
(0.0755102515308 0.458061302953 0)
(0.0797187033208 0.454009874245 0)
(0.0838999285441 0.449303191047 0)
(0.0880439150547 0.443692571549 0)
(0.0919675546762 0.436862133043 0)
(0.095830245644 0.428292833161 0)
(0.0989133871967 0.417047828077 0)
(0.101836368653 0.400715301027 0)
(0.101977294687 0.362953403101 0)
(0.0942780590496 0.303716350642 0)
(0.0789605055452 0.230634933371 0)
(0.0570724356466 0.151443505564 0)
(0.0285268614628 0.0736855220056 0)
(-8.34183047418e-05 7.21982246258e-05 0)
(-0.000462141176019 -0.00165772003767 0)
(-0.00014659662698 -0.00144724351647 0)
(-0.000128047109583 -0.00144564481936 0)
(-0.000119050041587 -0.0014434766467 0)
(-0.000116742435181 -0.00144156163081 0)
(-0.000115910809249 -0.00144359360034 0)
(-0.000112973078874 -0.00145278816162 0)
(-0.000105301541394 -0.00145578850672 0)
(-9.48418511266e-05 -0.00145710599367 0)
(-8.1517543161e-05 -0.00145753740362 0)
(-6.45356832828e-05 -0.00145529307057 0)
(-4.47078990923e-05 -0.00144927332973 0)
(-2.41621942368e-05 -0.00145577191972 0)
(-6.72893025737e-06 -0.00145985700066 0)
(-0.00024556102672 -0.00289389873139 0)
(0.000699448663529 -0.00346515612038 0)
(0.0010741661726 -0.00358446452529 0)
(0.000192620621986 -7.76967201852e-05 0)
(0.000317865311242 -5.80444455017e-05 0)
(0.000314242406105 -8.32987666386e-05 0)
(0.000337816566877 -9.813112856e-05 0)
(0.000292384726206 -0.000141301089751 0)
(0.000491131405077 -0.00260791780993 0)
(0.000194472054854 -0.0157802172564 0)
(0.000219298910584 -0.0209386743984 0)
(0.000359199823686 -0.0209331856834 0)
(0.00033465252497 -0.0158087647237 0)
(0.0004359268274 -0.000279593726945 3.29485039555e-28)
(0.000451768968641 -0.000115157894847 0)
(0.000536276774507 -0.000161018802999 0)
(0.000579970541046 -0.000192979229773 0)
(0.000604396128641 -0.000204765705798 0)
(0.000593978513401 -0.000184480394275 0)
(0.000594667697244 -0.000157491273909 0)
(0.000633749169951 -0.000146674191529 0)
(0.000681858662986 -0.000142982242813 0)
(0.000755890902602 -0.000142852446043 0)
(0.000828292923948 -0.000150527327198 0)
(0.000889766060891 -0.000169973213389 0)
(0.000977926099151 -0.000194912919244 0)
(0.00108593012561 -0.000221879062025 0)
(0.00118975856982 -0.00025199879075 0)
(0.001308963044 -0.000291562247971 0)
(0.00141626157933 -0.000338045435463 0)
(0.00157253175827 -0.000401364228229 0)
(0.00176875976006 -0.000479756263236 0)
(0.00198333511007 -0.000561971700252 0)
(0.0022446311919 -0.000639327090699 0)
(0.00255997991375 -0.000694491045516 0)
(0.00291105995382 -0.000694560869135 0)
(0.00348865119385 -0.000588379477056 0)
(0.00184402406235 -0.000306610933561 0)
(0.0128724028193 -0.0661772591963 0)
(0.000407735369975 -0.00075598596953 0)
(0.0204996464614 0.361923285716 0)
(0.0269005274485 0.469807869836 0)
(0.0341762140222 0.494010942302 0)
(0.0376145069705 0.49426675912 0)
(0.0414554838647 0.489782571778 0)
(0.0449606333778 0.485216829109 0)
(0.0486255806874 0.481327660605 0)
(0.0523509285643 0.477964431447 0)
(0.0561562684058 0.474903272667 0)
(0.0600344625517 0.471951679373 0)
(0.0639865625447 0.468949774803 0)
(0.0680039847072 0.465752868972 0)
(0.0720878074042 0.462216015609 0)
(0.0762093512049 0.458174108457 0)
(0.0803473091338 0.453441256453 0)
(0.0844812334413 0.447742550951 0)
(0.088425004012 0.440740339545 0)
(0.0923694168484 0.431836323973 0)
(0.0954637385455 0.42000780441 0)
(0.0985695526938 0.402389337218 0)
(0.0983895242494 0.358561330536 0)
(0.088996441477 0.291313307642 0)
(0.0716176692142 0.210663725562 0)
(0.0469670873897 0.125318484122 0)
(0.0116879021914 0.045319659031 0)
(-0.000460839192943 -0.00105111529064 0)
(8.8321995443e-05 -0.00143912304843 0)
(-0.000108677217702 -0.00141654647992 0)
(-0.000159458257749 -0.00143930034107 0)
(-0.000173720314295 -0.00143878339659 0)
(-0.000176083337606 -0.00144075052801 0)
(-0.000172063329326 -0.00144240952043 0)
(-0.000163051997306 -0.00144382608374 0)
(-0.000148127852422 -0.0014433288925 0)
(-0.000130249779248 -0.00144172651655 0)
(-0.000109750634043 -0.00144009796557 0)
(-8.46995006441e-05 -0.00143475361761 0)
(-5.95450205053e-05 -0.00142950082837 0)
(-3.68895695917e-05 -0.00143428379043 0)
(-1.25500504459e-05 -0.00143536947402 0)
(-0.000501708402029 -0.00303290085892 0)
(8.10496180837e-05 -0.000452066192693 0)
(0.0013539901299 -0.00414355453533 0)
(0.000211198878245 -0.000139887087426 0)
(0.0003190279183 -7.80945967967e-05 0)
(0.000309911649063 -8.38364605336e-05 0)
(0.000298558349901 -7.95923436681e-05 0)
(0.000213636264374 -4.31699537047e-05 0)
(9.91656097228e-05 -0.000387228399102 0)
(0.000428307877305 -0.0153016773062 0)
(0.000799840105113 -0.0206859285812 0)
(0.00102797516078 -0.0208998806268 0)
(0.00120691570162 -0.0158209041319 0)
(0.000469784751546 -0.000319670713741 0)
(0.000529046834302 -5.42857936344e-05 0)
(0.00059842519732 -0.000126319486328 0)
(0.000620368039907 -0.000173420596856 0)
(0.000627185036144 -0.000189936359429 0)
(0.000641761839888 -0.000179166734135 0)
(0.000668170719297 -0.000147992850143 0)
(0.000681086804312 -0.000111500656462 0)
(0.000721316809559 -8.58205706075e-05 0)
(0.000791135539025 -7.3144689837e-05 0)
(0.000857744915586 -7.76248100346e-05 0)
(0.000929585572409 -9.0220796576e-05 0)
(0.00102380725455 -0.000103531824031 0)
(0.00112647600694 -0.000119073106843 0)
(0.00122947013038 -0.000137248514243 0)
(0.00134973821983 -0.000161730721359 0)
(0.00147779697277 -0.000195188133841 0)
(0.0016347062183 -0.000236369797226 0)
(0.00183087317011 -0.000283655112504 0)
(0.00204065165324 -0.000329172877076 0)
(0.002285221799 -0.000365522464653 0)
(0.00256306234013 -0.000379495077518 0)
(0.00284771427147 -0.00034958144353 0)
(0.00332772962675 -0.000249629960748 0)
(0.00161517077505 -7.981189161e-05 0)
(0.0150801881672 -0.0587884339564 0)
(0.000645403994275 -0.000208334431663 0)
(0.0232010143923 0.374325039059 0)
(0.0289197527223 0.477244285513 0)
(0.0351636847808 0.498407374519 0)
(0.0375580041841 0.497592714094 0)
(0.0405476851664 0.49297098816 0)
(0.0434307303286 0.488523524894 0)
(0.0465952299476 0.484778809214 0)
(0.0499196339326 0.481542640355 0)
(0.0533959292051 0.478593214301 0)
(0.0570048938077 0.475744324842 0)
(0.0607390473872 0.472838361998 0)
(0.0645847715976 0.469729425114 0)
(0.0685435400095 0.466266620649 0)
(0.0725805999686 0.462276573484 0)
(0.0766870734828 0.457559027681 0)
(0.080826449444 0.451812873543 0)
(0.0848227455187 0.444678194914 0)
(0.0888883107767 0.435465138834 0)
(0.0920410424752 0.423072129142 0)
(0.0954258299916 0.404092694935 0)
(0.0949268240973 0.353064772483 0)
(0.0836259503655 0.276893446478 0)
(0.0638859008991 0.188206016924 0)
(0.0356816001541 0.09687179715 0)
(0.00340687856731 0.0146805522475 0)
(-0.000444099100721 -0.00216769630989 0)
(-0.000148779316117 -0.00161604868231 0)
(-0.000223991421179 -0.00151183670982 0)
(-0.000254182916787 -0.00146387037982 0)
(-0.00025970428038 -0.00144961775175 0)
(-0.000254219453317 -0.00143140904552 0)
(-0.000243203713258 -0.00143156111183 0)
(-0.000223070435216 -0.00142524760919 0)
(-0.000198551911123 -0.00142078328133 0)
(-0.000171205576882 -0.00141621785365 0)
(-0.000141395767525 -0.00141058428363 0)
(-0.00010851051948 -0.00139809996801 0)
(-7.87402043478e-05 -0.0014026952764 0)
(-5.09765594986e-05 -0.00140738042931 0)
(-1.8387864075e-05 -0.0014069372152 0)
(0.000425103903578 -0.00318565386777 0)
(7.84407358094e-05 -0.000385342809151 0)
(0.000762990805959 -0.00474802085866 0)
(0.000190646574436 -0.000156150887245 0)
(0.000329074695149 -8.50499685181e-05 0)
(0.000354616960351 -7.22508276716e-05 0)
(0.000416663315452 -6.33378005041e-05 0)
(0.000446134312039 -0.000127477049598 0)
(0.000491502596914 -0.00255881101129 0)
(0.000616613434728 -0.0147066342734 0)
(0.00139929560431 -0.0201995757474 0)
(0.00175891688745 -0.0207942333014 0)
(0.00208946466541 -0.0162216652412 0)
(0.000694419624645 -0.000980973311725 0)
(0.000561856327261 -5.42744234051e-05 0)
(0.000647334230422 -0.000101578144586 0)
(0.000675281877543 -0.000161642808709 0)
(0.000677492591033 -0.000187496658007 0)
(0.000671845923841 -0.000166301405546 0)
(0.000680511564935 -0.000119501266231 0)
(0.00072070664903 -7.27361223508e-05 0)
(0.000778113835156 -3.38389267153e-05 0)
(0.000834414405342 -1.34025240327e-05 0)
(0.00088316903809 -9.82886323488e-06 0)
(0.00095442357658 -1.02015715672e-05 0)
(0.00104013918052 -9.25181865601e-06 0)
(0.00115914031209 -1.14035663169e-05 0)
(0.00127168486225 -1.91982259672e-05 0)
(0.00140058006943 -3.09031773262e-05 0)
(0.00150453299663 -4.93741934621e-05 0)
(0.00167057835124 -7.21380050847e-05 0)
(0.00186158063086 -9.04181593368e-05 0)
(0.00206520355465 -0.000106495250353 0)
(0.00229495567709 -0.0001152982121 0)
(0.00254404152278 -0.000108983191348 0)
(0.00278116522908 -7.43960697054e-05 0)
(0.00318130362413 5.18767162094e-06 0)
(0.00147579816384 0.000144778415963 0)
(0.0159703833298 -0.0495657058631 0)
(0.000790940719374 -2.06383557283e-05 0)
(0.0249012869317 0.387596668862 0)
(0.0301118541961 0.484011940022 0)
(0.0354206566927 0.501802660569 0)
(0.0370243939154 0.500077192505 0)
(0.0393265191993 0.495502262981 0)
(0.0416786178437 0.491303975207 0)
(0.0443877903596 0.487797448591 0)
(0.0473304180757 0.48476148989 0)
(0.0504827387206 0.481984556661 0)
(0.0538206280214 0.479291487655 0)
(0.0573322425878 0.476530230991 0)
(0.061002184342 0.473556184681 0)
(0.0648341741977 0.470214216933 0)
(0.068789433886 0.466324495771 0)
(0.0728762259807 0.461671199044 0)
(0.077035967742 0.455928095981 0)
(0.0811209168043 0.448710547927 0)
(0.0853457372769 0.439224387002 0)
(0.0886091245778 0.426300570519 0)
(0.0923709628074 0.405897591888 0)
(0.0915758712738 0.346328978561 0)
(0.0781711206127 0.260355516236 0)
(0.0556798734603 0.163544357711 0)
(0.0227542886336 0.0666383166091 0)
(-0.000401554172603 -0.000954569810689 0)
(-0.000182988083176 -0.00178369670649 0)
(-0.000220245665018 -0.00167214260089 0)
(-0.000315336564042 -0.00156889078802 0)
(-0.000353618445468 -0.00146865759936 0)
(-0.000362618693006 -0.00144120154027 0)
(-0.000350382587781 -0.00142297111443 0)
(-0.000327809983044 -0.00140636046797 0)
(-0.000295417831472 -0.00139491873825 0)
(-0.000258321578353 -0.00138711746961 0)
(-0.000218717881795 -0.00138021799744 0)
(-0.000177238858143 -0.00137220595643 0)
(-0.000137145766775 -0.0013630772655 0)
(-0.000100888770905 -0.00136887522915 0)
(-6.47871910568e-05 -0.00137080524002 0)
(-2.34479121577e-05 -0.00135827488642 0)
(0.00119572103388 -0.00286127350771 0)
(0.000318713206164 -0.000676064109702 0)
(0.000459278530985 -0.00478741729438 0)
(0.00019346173792 -0.000133280271465 0)
(0.000384996875839 -6.67441660371e-05 0)
(0.000428499033677 -2.89034041591e-05 0)
(0.000472172902406 2.90811768162e-05 0)
(0.000367354737229 3.59831644543e-05 0)
(0.000600664393777 -0.00247732166357 0)
(0.000958634470346 -0.0136949212975 0)
(0.00212971563001 -0.0194261405058 0)
(0.00270973671003 -0.0205142000679 0)
(0.00388195207887 -0.0167176970547 0)
(0.000677800873889 -0.000900379250947 0)
(0.000496481841803 0.000143840561556 0)
(0.000779222351577 -4.79047746391e-05 0)
(0.000820496038095 -0.00016831244703 0)
(0.00079436577158 -0.000228150453122 0)
(0.00072734063223 -0.000199637054847 0)
(0.000676186750071 -0.00010594740044 0)
(0.000710261950329 -1.95338634064e-05 0)
(0.000775008440878 3.0764912389e-05 0)
(0.000848453261544 5.0727255375e-05 0)
(0.000917171431181 5.826828397e-05 0)
(0.000993090864881 6.86378664196e-05 0)
(0.00108854422463 8.53166258031e-05 0)
(0.00119150188796 9.65300540658e-05 0)
(0.00128674600285 9.71521516277e-05 0)
(0.00140710232634 9.49499019781e-05 0)
(0.00150023014726 9.02671904974e-05 0)
(0.00167776497019 9.32104739464e-05 0)
(0.00186523094202 9.98319891916e-05 0)
(0.00206552901067 0.000108462856768 0)
(0.00228771058574 0.000119072831045 0)
(0.00252216687239 0.00013263614332 0)
(0.00273353477493 0.00015321275842 0)
(0.00307683641318 0.000189127494141 0)
(0.00141916492906 0.000258847027447 0)
(0.0162304761961 -0.0392086879682 0)
(0.000866221627875 0.000132508392155 0)
(0.025721915546 0.401181437428 0)
(0.0305287024353 0.490107127784 0)
(0.034962779756 0.50438540166 0)
(0.0359682725816 0.501900203734 0)
(0.0377249745279 0.497497328332 0)
(0.0396335848598 0.493627738095 0)
(0.0419369177672 0.490419869899 0)
(0.0445237914501 0.487637584212 0)
(0.0473634640538 0.485082636795 0)
(0.0504327711897 0.48259256594 0)
(0.0537195061783 0.480022534728 0)
(0.0572100258824 0.477230867089 0)
(0.0609122235975 0.474059725423 0)
(0.0647868486327 0.470324504518 0)
(0.0688637380027 0.465792322295 0)
(0.0730571902498 0.460114282397 0)
(0.0772715671815 0.452875152985 0)
(0.0816927728142 0.443163025953 0)
(0.0851243838024 0.429750524689 0)
(0.0893415245004 0.407841374362 0)
(0.0882208700075 0.338015261058 0)
(0.07225779693 0.241273560444 0)
(0.0463820626593 0.137057287907 0)
(0.0110120687287 0.037016662969 0)
(-0.000701900121066 -0.00200631935664 0)
(-0.000211477523976 -0.00194305295568 0)
(-0.000363140849975 -0.00177834785868 0)
(-0.000440283500609 -0.00163661036172 0)
(-0.000480827891962 -0.00149727851852 0)
(-0.000489745873882 -0.00142724973506 0)
(-0.000468322897068 -0.00139750244735 0)
(-0.000430701381458 -0.00137083564581 0)
(-0.000384382425812 -0.00135215093646 0)
(-0.000331859216739 -0.00134118310685 0)
(-0.000276558071655 -0.00133366612373 0)
(-0.000221231823917 -0.00132420867493 0)
(-0.000171179667275 -0.00132209232871 0)
(-0.000124009237006 -0.00132484997104 0)
(-7.747428774e-05 -0.00132916459281 0)
(-2.69750239984e-05 -0.00130716738351 0)
(0.00019250434533 -0.000439245870918 0)
(0.00127514740144 -0.00233178613714 0)
(0.000423128749963 -0.00471139451544 0)
(0.000158448565876 -0.00010697655752 0)
(0.000315283495934 -1.30005892642e-05 0)
(0.000376902843392 2.16530661928e-05 0)
(0.000431327495806 6.74896355839e-05 0)
(0.000321377018423 7.67231389714e-05 8.13026611566e-29)
(0.000701231271958 -0.00220115435623 -5.37608399207e-28)
(0.00139917221323 -0.0124413837064 0)
(0.00291094885589 -0.01833424894 0)
(0.00378072915652 -0.0198483098682 0)
(0.00493892497673 -0.0168347784929 0)
(0.00332674924046 -0.00613449991458 0)
(0.000581140520283 0.00022121170663 0)
(0.000988259174682 5.91483136391e-06 0)
(0.00095876098502 -0.000192417272485 0)
(0.000879512678831 -0.000303578424158 0)
(0.000760023070322 -0.000279901272914 0)
(0.000691719333228 -0.000118925220373 0)
(0.000714512707912 3.52008261399e-05 0)
(0.000779353912478 0.000102016610735 0)
(0.000855544687823 0.000125239424957 0)
(0.000929143547782 0.000136088453984 0)
(0.00101639681037 0.000153814342266 0)
(0.00110828967108 0.000176667381495 0)
(0.00119820548976 0.000192439861161 0)
(0.00129076863987 0.000200407548105 0)
(0.00139386920475 0.000210217115862 0)
(0.00149186192935 0.00022864323686 0)
(0.00165807047063 0.000258202123713 0)
(0.0018463264021 0.000288227905792 0)
(0.00204596584174 0.00032127387171 0)
(0.00227078302275 0.000349998575612 0)
(0.00250989727696 0.00036642460206 0)
(0.00272464753035 0.000362056664083 0)
(0.00305051918375 0.000332192807961 0)
(0.00144638042487 0.000283062969645 0)
(0.0161600003877 -0.0284055325338 0)
(0.00087928635603 0.000251570885275 0)
(0.0257892378545 0.414860842117 0)
(0.0302341801561 0.495514081217 0)
(0.033847230214 0.506297122569 0)
(0.0343988199611 0.503205597392 0)
(0.0357208135043 0.499056960883 0)
(0.0372581748659 0.495557523087 0)
(0.0391992985997 0.492682479069 0)
(0.0414553852249 0.490190034563 0)
(0.0439943313352 0.487895231974 0)
(0.0467977363962 0.485648213103 0)
(0.0498562652153 0.48331215498 0)
(0.0531612986195 0.48074952737 0)
(0.0567266482674 0.477801543957 0)
(0.0605177078117 0.474280497168 0)
(0.0645891633802 0.469935321792 0)
(0.0688262309558 0.464398695744 0)
(0.0732155959887 0.457214957233 0)
(0.0778736569363 0.447345324936 0)
(0.0815643693297 0.433511794947 0)
(0.0863565852392 0.410000873851 0)
(0.0848797903388 0.327623709681 0)
(0.0652574693092 0.218498638084 0)
(0.0342163379112 0.106447409138 0)
(-1.56788272867e-05 0.00055671613692 0)
(-0.000750995462368 -0.00208148555995 0)
(-0.000452967750297 -0.00198502223062 0)
(-0.000526721254475 -0.00185900052002 0)
(-0.000596609984986 -0.00169806564381 0)
(-0.000639449902033 -0.00153056209983 0)
(-0.0006425758446 -0.00141527045263 0)
(-0.00061047175306 -0.00136019782572 0)
(-0.000556701837843 -0.0013216136526 1.47118725206e-30)
(-0.000493090502135 -0.00129458619474 0)
(-0.000421498900298 -0.00127751812313 0)
(-0.000347539339573 -0.00126817124463 0)
(-0.000277146005519 -0.00126265336529 0)
(-0.000213444809146 -0.00126766173541 0)
(-0.000152422044064 -0.00127273578069 0)
(-9.26140280413e-05 -0.00127839403412 0)
(-3.05511178701e-05 -0.00125145312699 0)
(-1.1537330493e-06 -0.000133567464065 0)
(0.000571311712473 -0.00265468814054 0)
(0.000811021782127 -0.00459298500745 3.87532772536e-28)
(0.000134491181394 -0.000116749628581 0)
(0.000219990533654 5.35271227432e-05 0)
(0.00035841158889 9.08555627915e-05 0)
(0.000379791487847 0.000110932383478 0)
(0.000269660714097 0.000137927316024 0)
(0.000844990196494 -0.00190016951495 0)
(0.00186282490129 -0.0109990651598 0)
(0.00354412155431 -0.0169850037191 0)
(0.00456999229427 -0.0189179243237 0)
(0.00538855968355 -0.0166590060841 0)
(0.00374856223276 -0.00864935664009 0)
(0.000780159272105 -3.7356417028e-05 0)
(0.00122117970958 -1.59452300303e-05 0)
(0.00119171912588 -0.000272042688153 0)
(0.0010755517175 -0.00046181350718 0)
(0.000861855409384 -0.000390298986713 0)
(0.000666301461798 -0.000136915677149 0)
(0.000687293919728 0.000111292818694 0)
(0.000787060559075 0.000186755811836 0)
(0.000873510208046 0.000204942286737 0)
(0.000947003711828 0.000211314387922 0)
(0.00101134848967 0.000228844092151 0)
(0.00109797474778 0.000258946636258 0)
(0.00117609165573 0.000280947414907 0)
(0.00126950937334 0.00029949547105 0)
(0.00137828068448 0.000323913697271 0)
(0.00147835470694 0.000363048853699 0)
(0.00160852783658 0.000414515692699 0)
(0.00180213833222 0.000474978941778 0)
(0.00200375649043 0.000538563637045 0)
(0.00224255753606 0.000593229215894 0)
(0.00251010793519 0.000620233878644 0)
(0.00276776018711 0.000592828232611 0)
(0.00313760822802 0.000481743647683 0)
(0.00156503217666 0.00025102469615 0)
(0.0158892379778 -0.0177341581726 0)
(0.000837000994813 0.000333642333873 0)
(0.025227993031 0.428392518834 0)
(0.0293027549431 0.500194086319 0)
(0.0321564229854 0.507639936288 0)
(0.0323561423805 0.504098707005 0)
(0.0333184586845 0.500256138796 0)
(0.0345370652577 0.497143053482 0)
(0.0361492018491 0.494616127641 0)
(0.0380939907282 0.49243558098 0)
(0.0403410032245 0.490428506709 0)
(0.0428781855423 0.488456879112 0)
(0.0457012675503 0.486392489028 0)
(0.0488092534985 0.484103275406 0)
(0.0522233645768 0.481431963354 0)
(0.0559201705231 0.478189785481 0)
(0.0599804288435 0.47410809553 0)
(0.0642640355408 0.468807238165 0)
(0.0688728445604 0.461776342737 0)
(0.0738006255338 0.451851006004 0)
(0.077881930915 0.437715326878 0)
(0.0834939157456 0.412576356122 0)
(0.0820021760963 0.314954940143 3.07606078007e-30)
(0.0578718736784 0.192209378319 0)
(0.0167519468724 0.072196055287 0)
(-0.000598529612634 -0.00147400031213 0)
(0.000157842386495 -0.00223711439394 0)
(-0.000435172928607 -0.00214784526845 0)
(-0.000650102472236 -0.00197633382687 0)
(-0.000768793065107 -0.00177011129478 0)
(-0.000824180135256 -0.00156307508751 0)
(-0.000807680224173 -0.00137363419077 0)
(-0.000781046055749 -0.00130709540164 0)
(-0.000707154984393 -0.00125447157569 -1.48017000306e-30)
(-0.000622335046887 -0.00121660406472 0)
(-0.000530665593189 -0.00119290919527 0)
(-0.000440903499882 -0.00119345646514 -1.88135497893e-30)
(-0.000350022966095 -0.00119565895434 0)
(-0.000264556411213 -0.00120164822141 0)
(-0.000186612479417 -0.00120644041335 0)
(-0.000111277501178 -0.00121094549258 0)
(-3.49319855768e-05 -0.00118523068927 0)
(-1.26028108907e-05 -4.61757442909e-05 0)
(0.000425057208739 -0.00236462172579 0)
(0.00149495093839 -0.00442837794084 -3.7061970934e-28)
(0.000728397488047 -0.000867329599639 0)
(0.00025699859596 0.000122465132098 0)
(0.000347471596403 0.000103042689249 0)
(0.000303038091659 8.54886202491e-05 0)
(0.000197995285391 7.62273194765e-05 0)
(0.000105960596207 -0.000183245575431 0)
(0.00217638445363 -0.00924330933899 0)
(0.00405857984909 -0.0154509658998 -1.43038591173e-28)
(0.00525484179772 -0.01802011353 0)
(0.0058239527118 -0.0169251037532 0)
(0.00448688308814 -0.0114255701511 0)
(0.00101180018282 -0.000632252029176 0)
(0.00134832401979 -2.67547178898e-05 0)
(0.00142876626035 -0.000337126351253 0)
(0.00128343439206 -0.000619473190837 0)
(0.00152853907905 -0.000872698873812 0)
(0.000905268344113 -0.000172855077535 0)
(0.00067503260298 0.000235097314876 0)
(0.000775788635557 0.000271801700475 0)
(0.000873970950963 0.00028034099965 0)
(0.000958531606428 0.000275136244617 0)
(0.00102128364753 0.000291693891714 0)
(0.00108175222375 0.00033056452986 0)
(0.00115213000752 0.000366069942282 0)
(0.00123687540011 0.000395417540788 0)
(0.00132880983907 0.000425219303183 -3.14472860179e-30)
(0.00142920659169 0.000478303774154 0)
(0.00152104963123 0.00055413091249 0)
(0.00172222741429 0.000661547041831 0)
(0.00192771327272 0.000765886025936 0)
(0.00218910798888 0.000865215151626 0)
(0.00251029309507 0.000928480903368 0)
(0.0028631396338 0.000904482529442 0)
(0.00338101383516 0.000715139539298 0)
(0.00179813845791 0.000160937942304 0)
(0.0155316013111 -0.00816713817869 0)
(0.000743125111715 0.00035285160014 0)
(0.0241886869645 0.441501470348 0)
(0.0278207937549 0.504093863505 0)
(0.0299793196721 0.508494798948 0)
(0.0298906416654 0.504660187114 0)
(0.0305342146596 0.501150326394 0)
(0.0314680969252 0.498421656658 0)
(0.0327740114271 0.496243945649 0)
(0.0344198208866 0.494385518612 0)
(0.0363784545606 0.49268389805 0)
(0.0386439292033 0.491011806844 0)
(0.0412180487198 0.489250316842 0)
(0.0441089685258 0.487274601187 0)
(0.0473464375274 0.484932340225 0)
(0.0509253323577 0.482036657508 0)
(0.0549511735969 0.478305758527 0)
(0.0592724906654 0.473356145188 0)
(0.0641363552423 0.466603748102 0)
(0.0693444800465 0.45677300722 0)
(0.0739535991578 0.442497031594 0)
(0.0805703082364 0.415719114941 0)
(0.0791641264958 0.299584721172 -3.2360176212e-30)
(0.0495972895483 0.163182172473 0)
(0.0105444226048 0.0386315216925 0)
(-0.000793526169622 -0.00332967415957 0)
(-0.00035112384147 -0.00276884616268 0)
(-0.00071408679625 -0.00244179775874 0)
(-0.000904430889323 -0.0021346823283 0)
(-0.00100987926944 -0.00184710278745 0)
(-0.00104935036943 -0.0015851229418 0)
(-0.00101799008894 -0.00135093293685 0)
(-0.00097436676963 -0.0012300182985 0)
(-0.00088420940018 -0.0011632648589 0)
(-0.000775800682477 -0.00111989634097 0)
(-0.000661536295097 -0.00109279978403 0)
(-0.000546425461718 -0.00108389831686 1.96826469855e-30)
(-0.000432522314208 -0.00108770131855 0)
(-0.000324836337896 -0.0011070138003 0)
(-0.000228090929544 -0.00112612997047 0)
(-0.000134904708712 -0.001121473355 0)
(-4.28084662224e-05 -0.00110753022684 0)
(-2.85599244269e-05 -6.38346401862e-05 0)
(5.03182070666e-05 -0.000320905419752 0)
(0.00164124089986 -0.00395827744023 3.83074000076e-28)
(0.00102810527456 -0.00216718963506 0)
(0.000194508529253 1.56310933206e-05 0)
(0.000266590810788 3.10810686206e-05 0)
(0.000200128754162 2.2357784812e-05 0)
(0.000189692950579 1.43999509411e-05 0)
(2.49079703563e-05 -0.000109098818898 0)
(0.00201100373417 -0.00761638455712 0)
(0.00472403768097 -0.0139229042005 1.48863531991e-28)
(0.0061400326076 -0.0171532967478 0)
(0.00670454062476 -0.0173195774715 0)
(0.00684601395322 -0.013930098515 0)
(0.00155750429724 -0.00113009676964 0)
(0.00130481887723 0.000319934401635 0)
(0.00153883608207 -0.000446201003654 0)
(0.00120695060818 -0.000661121486688 0)
(0.00143128899138 -0.000739407584347 0)
(0.00499249035409 -0.00146637113573 0)
(0.000833198498011 8.03195914308e-05 2.03356000053e-28)
(0.000790395010342 0.00034208270374 -1.02317093335e-28)
(0.000922167450921 0.00039897984635 0)
(0.00101752807019 0.000335483709625 -7.74941862409e-30)
(0.00103894042131 0.000322631715714 0)
(0.00105927974208 0.000380851176012 0)
(0.00111409836311 0.000441041252216 0)
(0.00119486676648 0.000483983241733 0)
(0.00128382598778 0.000514650795486 3.31871022479e-30)
(0.00137509880179 0.000574877598488 0)
(0.00144741830023 0.000686244241137 0)
(0.00158973768918 0.000835610487999 0)
(0.00180008246337 0.00100127969544 0)
(0.00207995411148 0.00117596998106 0)
(0.00247081719873 0.00132750893716 0)
(0.00298106326575 0.00138747926147 0)
(0.00387618785531 0.00121026892411 0)
(0.00221884387171 0.000205483974901 0)
(0.0162669006109 0.00320979506425 0)
(0.000634603011103 0.000271393456145 0)
(0.0228548149208 0.453972897649 0)
(0.025857415637 0.507232925493 0)
(0.027384577124 0.508971467354 0)
(0.027054859769 0.504967022011 0)
(0.0273948743102 0.501778973158 0)
(0.0280606268638 0.499414952475 0)
(0.0290725446472 0.497577314798 0)
(0.0304234874335 0.496042561324 0)
(0.0320908865047 0.494655800284 0)
(0.0340728994255 0.493299107024 0)
(0.0363768585663 0.491863825845 0)
(0.0390200790738 0.490234932435 0)
(0.0420413160493 0.488269512573 0)
(0.0454595187556 0.485786634599 0)
(0.0494003780965 0.482500485769 0)
(0.0537282296133 0.478033820294 0)
(0.0588567767651 0.471719352208 0)
(0.0643399283947 0.462221434618 0)
(0.0696954967983 0.448062806827 0)
(0.0774643629903 0.419627406352 0)
(0.0756852475525 0.280263761206 0)
(0.0380387635955 0.128237839574 0)
(7.03298583406e-06 0.000141130153399 0)
(-0.000746620323093 -0.00334942297622 0)
(-0.00076342365307 -0.00305505090813 0)
(-0.00106943634999 -0.00267556159913 0)
(-0.00124480976588 -0.00226836925742 9.2318175462e-31)
(-0.00131835407535 -0.0018982243636 0)
(-0.00132051967457 -0.00157956426357 0)
(-0.00126529286752 -0.00131256120389 0)
(-0.00117643917602 -0.00112979135635 0)
(-0.00108118554397 -0.00104875012943 0)
(-0.000950057578704 -0.000999147643727 0)
(-0.000811825961401 -0.000969765040373 0)
(-0.000673077969057 -0.000963291812409 0)
(-0.000534225125661 -0.000969772846647 0)
(-0.000399391559664 -0.000986670283728 0)
(-0.000283607410991 -0.00102978968025 0)
(-0.000168740576285 -0.00101681969817 0)
(-5.83421534755e-05 -0.0010152010549 0)
(2.22518935932e-05 -8.40875379759e-05 0)
(-4.15218617324e-07 -0.000177202674834 0)
(0.000717962359091 -0.00365963693574 -4.40708239111e-28)
(0.000503744442646 -0.00261646370562 0)
(0.000140034931494 -4.52171303987e-05 0)
(0.000218940876666 -1.75641686415e-05 0)
(0.00018639186993 -9.53441737659e-06 0)
(0.000152205508964 -1.09799505857e-05 0)
(1.27117695517e-05 -3.6052818204e-05 0)
(0.000635876293364 -0.00202559027098 0)
(0.00529541543892 -0.0115667733929 0)
(0.00696193124057 -0.0158927013291 0)
(0.00777674787465 -0.0172457478551 0)
(0.00780285074414 -0.0155533697994 0)
(0.00661215899637 -0.00973166751093 0)
(0.00158308894616 -0.000705887524584 0)
(0.0017469710319 -0.000888521999971 0)
(0.00140862093236 -0.000507845880042 -2.05589121371e-28)
(0.00789304031357 0.00195738527241 2.05672035459e-27)
(0.009435599273 -0.0014455754029 0)
(0.0101334545595 -0.00478724692402 0)
(0.00211526843858 -0.000330803546005 -2.77886903601e-28)
(0.001035585415 0.000349067358175 9.11584316101e-29)
(0.0011722696637 0.000331605667156 8.8796017261e-30)
(0.00109305280085 0.00027516903497 0)
(0.00102476291901 0.000398882766876 0)
(0.00106266438431 0.000513796976207 0)
(0.00115411301069 0.000585243833106 0)
(0.00126368436999 0.000598139018154 0)
(0.00132276124874 0.000624339716871 0)
(0.00134809730303 0.000767878864643 0)
(0.00137422224127 0.000945000228538 0)
(0.00158732363032 0.00123380232258 0)
(0.00186287750729 0.00152016806583 0)
(0.00229874233846 0.00183472106989 0)
(0.00298006488286 0.00217003203236 0)
(0.00456189830962 0.00244581146088 0)
(0.00299795992159 0.00275799184203 0)
(0.0217582615158 0.0106522882271 0)
(0.000765229363072 -0.00132861796118 0)
(0.02142943687 0.466110630305 0)
(0.0234861946058 0.509811228333 0)
(0.0244627798983 0.509165924679 -4.26326234811e-30)
(0.0239359754618 0.505039736607 0)
(0.0239505362652 0.502132410923 0)
(0.0243344175769 0.50011234704 0)
(0.0250501398781 0.498609808443 0)
(0.0261023429859 0.49739983322 0)
(0.0274702538384 0.496332271308 0)
(0.0291516020122 0.495298643784 0)
(0.0311565476116 0.494203143969 0)
(0.0335098691185 0.492944829653 0)
(0.0362592127892 0.491396197654 0)
(0.0394503308936 0.4893881836 0)
(0.0432218437664 0.48664322032 0)
(0.0474884624645 0.482794482226 0)
(0.0528150380382 0.477094752105 0)
(0.0584955564974 0.468252693814 0)
(0.0649358920141 0.454629864221 0)
(0.0743159718526 0.424966797661 0)
(0.0725669750822 0.257276894839 0)
(0.0223309831514 0.0880415737617 0)
(-0.000677124246316 -0.0030688124532 0)
(0.000319845590334 -0.00414617680137 0)
(-0.00102638471159 -0.00358349040719 0)
(-0.001500765392 -0.00294974081907 0)
(-0.00168176252038 -0.00237349617944 -9.2279085423e-31)
(-0.00169868356483 -0.00190078576382 0)
(-0.00163511735109 -0.00152573020115 9.64416669409e-31)
(-0.00153313287201 -0.00123220849703 0)
(-0.00137310737616 -0.00100126390456 0)
(-0.001278145234 -0.000910382747596 0)
(-0.00112857154632 -0.000853717728188 0)
(-0.000970214432178 -0.000820767682796 0)
(-0.000813951945786 -0.000814961320777 0)
(-0.000654413555239 -0.000828213664345 0)
(-0.000492450911908 -0.000850484090348 0)
(-0.000353614980499 -0.000902890872149 0)
(-0.000215424711329 -0.000908396801853 0)
(-7.48787811931e-05 -0.000893329380233 0)
(2.0659217338e-05 -2.87409634874e-05 0)
(-1.28567529881e-05 -3.92383141735e-05 0)
(7.00085372541e-05 -0.0032757871185 4.8631901597e-28)
(0.000321233469365 -0.00284151397867 0)
(0.000122398071434 -4.56391515438e-05 0)
(0.00020626131261 -4.64650464408e-05 0)
(0.000170132005018 -3.80683628846e-05 0)
(0.000155736706723 -3.57563720692e-05 0)
(0.00018194791675 -4.82379539962e-05 0)
(6.69622649871e-05 -0.000323090753683 0)
(0.00450828233653 -0.00942293696207 0)
(0.00754917617583 -0.0145469988401 0)
(0.00873109054436 -0.0169842827238 0)
(0.00948696232757 -0.0176783339491 0)
(0.00233500117669 -0.00242564191736 0)
(0.00164955343497 -0.0012471805495 0)
(0.00149988329347 -0.000611111620251 0)
(0.00937177962602 0.00599349600046 0)
(0.0129605097407 0.00817252387065 0)
(0.0153196133898 0.00226969879827 0)
(0.0154605771946 -0.00486761228783 0)
(0.0139724987733 -0.00807399236346 0)
(0.00223261105127 -0.000694354706723 0)
(0.00157683682844 0.000288528261768 0)
(0.00136213144758 -7.43951252606e-05 0)
(0.000964345840679 0.000308439731612 0)
(0.000972712799848 0.000557887564412 0)
(0.00110026520821 0.00076894593977 0)
(0.00130925409852 0.000713877134145 0)
(0.00135151086125 0.000582227218306 0)
(0.00122774573543 0.000748717800543 0)
(0.00116806455074 0.00101050856183 0)
(0.00124792881188 0.00135105136759 0)
(0.00147915474817 0.0017946120757 0)
(0.00182102837332 0.00232503599176 0)
(0.00237034260192 0.00299222304604 0)
(0.00329829149955 0.00387070959553 -2.20633892969e-30)
(0.00450542105038 0.00550523149105 0)
(0.00457627979898 0.00379418502366 0)
(0.00111297431854 8.59146305914e-05 0)
(0.0201801868866 0.479149114929 0)
(0.0211773891769 0.511670006691 0)
(0.0214678153687 0.508809942291 4.28862555107e-30)
(0.0206469583273 0.504693106526 0)
(0.0202397270384 0.502111633753 0)
(0.0202914699902 0.5004700862 0)
(0.0207017297597 0.499325936483 0)
(0.0214530131823 0.49844962299 0)
(0.0225146111346 0.497701275779 0)
(0.0238765575854 0.496987595265 0)
(0.0255474461938 0.496231368894 0)
(0.027556380113 0.495352436608 0)
(0.0299590707283 0.494247460074 0)
(0.0328279144604 0.492770549678 0)
(0.0363120999817 0.490670858233 0)
(0.0404143322622 0.487592352705 0)
(0.045769239789 0.482723246098 0)
(0.0514262800646 0.474877082036 0)
(0.0590665470463 0.462038085979 0)
(0.069944865669 0.431663301657 0)
(0.0692098479482 0.230043895774 0)
(0.0206551113184 0.0507466437973 0)
(-0.0010955464631 -0.0073535611149 0)
(-0.000743381276382 -0.00572263355248 0)
(-0.00196041328169 -0.00428595957728 0)
(-0.00227928918655 -0.00318617635197 0)
(-0.00229374034721 -0.00238407715551 0)
(-0.00216612172191 -0.00180803649661 0)
(-0.00198913649453 -0.0013921944085 -9.64247315951e-31)
(-0.00180898310499 -0.00108767127216 0)
(-0.00158151109424 -0.000852284002856 0)
(-0.00145817284673 -0.000749820153444 1.24756252361e-30)
(-0.00129722855001 -0.000690103719445 0)
(-0.00112715062767 -0.000657852932787 0)
(-0.00094944172581 -0.000644693966768 0)
(-0.000781094678624 -0.000660667273736 0)
(-0.000609095534009 -0.000701869842653 0)
(-0.000438524930902 -0.000765318763466 0)
(-0.000243826573934 -0.000767178861787 0)
(-6.89589381893e-05 -0.000706447400317 0)
(1.30175799611e-05 -1.98099625164e-05 0)
(-0.000164513565409 -0.00045155909322 0)
(5.80412784905e-05 -0.0028508277981 -5.14500356831e-28)
(0.000534941430962 -0.00292362790061 0)
(0.000128271314259 -8.03367089102e-05 0)
(0.000193511454332 -0.000104540571356 0)
(0.000134080288546 -7.21057232217e-05 0)
(0.00011516758892 -4.43292092507e-05 0)
(0.000114594335199 -2.41132722836e-05 0)
(2.5174394511e-05 2.61040129233e-06 0)
(0.000652492821363 -0.00123195569721 0)
(0.00786140524362 -0.0114545929955 0)
(0.0108757487843 -0.0151555651816 0)
(0.0144164900939 -0.0179655645315 0)
(0.0205313556083 -0.0158207236565 0)
(0.0020460774986 -0.00102978297798 0)
(0.0152863346608 0.00609170888235 0)
(0.0174631937299 0.010541298028 0)
(0.0157690839187 0.0113666536929 0)
(0.0106364980026 0.000390825741318 0)
(0.0141622093374 -0.00650177998421 0)
(0.0149608517459 -0.0103583142762 0)
(0.0158627413373 -0.0114406889598 0)
(0.00319008347743 -0.00116945677024 0)
(0.00151505947077 -7.188441097e-05 0)
(0.000790722717761 0.000466284269318 0)
(0.000774210158271 0.000658099033765 0)
(0.00113224309514 0.000642956866739 0)
(0.00152063703011 0.000986081716194 0)
(0.00167215400716 0.000290007006096 0)
(0.00120177074644 0.00053316212652 0)
(0.000915226284855 0.00102568984961 0)
(0.000878336895959 0.00158199728899 0)
(0.00092862623055 0.00204521781715 0)
(0.00110151336181 0.00270755114275 0)
(0.00143549208251 0.0037150971518 0)
(0.00204979464429 0.00506838987414 2.20679076186e-30)
(0.0030746881213 0.00697272371868 0)
(0.00604360886763 0.00932541707662 0)
(0.0041890289596 0.00566100264259 0)
(0.0233187476081 0.488482450418 0)
(0.0202586256739 0.511480660088 0)
(0.0184995716171 0.507182538571 0)
(0.0170519877722 0.503613597534 0)
(0.0161547920641 0.501624499738 0)
(0.0158658000885 0.500479613822 0)
(0.0159970362241 0.499738843169 0)
(0.0164701347886 0.499200769007 0)
(0.0172317554053 0.498756390881 0)
(0.0182598864123 0.498339144006 0)
(0.0195582652539 0.497897504524 0)
(0.0211559465133 0.497378867207 0)
(0.0231124426469 0.496713778536 0)
(0.0255203295246 0.49579736238 0)
(0.028544132551 0.494438141637 0)
(0.0323135110874 0.49232593852 0)
(0.0374559763157 0.488679377414 0)
(0.0430094794242 0.482384086935 0)
(0.0520294550249 0.470410988084 0)
(0.0630766221456 0.439045206287 0)
(0.0608592479775 0.192009835214 0)
(0.00190584780601 -0.00247557675215 0)
(-0.00107029298694 -0.0110305053127 0)
(-0.00293739370067 -0.00711475253656 0)
(-0.00356286293875 -0.00465877347635 0)
(-0.00340268474756 -0.00312987703097 0)
(-0.0030599409898 -0.00216817319032 0)
(-0.00269058945565 -0.00155281666915 0)
(-0.00235549574055 -0.00114579766063 0)
(-0.00207322187183 -0.000865832762775 0)
(-0.00178874106536 -0.000664363500831 0)
(-0.00161001547439 -0.00056512213333 -1.21514533902e-30)
(-0.00144086742786 -0.000512095659902 0)
(-0.00125785375796 -0.000480808842054 0)
(-0.00107461557979 -0.000470723013226 0)
(-0.000887196961292 -0.000478780174732 0)
(-0.000693208191784 -0.00050357507557 0)
(-0.000488543261087 -0.000542164756233 0)
(-0.000248807531854 -0.000536898727305 0)
(-7.10557215807e-05 -0.000566898494471 0)
(-6.09820568745e-06 1.46287932917e-06 0)
(-2.00438257988e-05 -0.000441861108264 0)
(0.000616952928805 -0.00239176476632 -5.47776419578e-28)
(0.00207127774687 -0.00307412094213 0)
(0.000231219752155 -0.0001410565831 0)
(0.000189974199664 -5.55183530852e-05 0)
(9.36824849696e-05 -3.43487488061e-05 0)
(8.90511318416e-05 -2.03720897207e-05 0)
(9.74358534669e-05 -1.12283192757e-05 0)
(0.000194251106241 8.58393938092e-07 0)
(0.000188907415889 -0.000102990313034 0)
(0.00614309063193 -0.00695482237667 0)
(0.0118175096989 -0.0104391219182 0)
(0.0183191832855 -0.0128214152638 0)
(0.0260975046962 -0.0125547747757 0)
(0.0291411989062 -0.00654368775909 0)
(0.0292263421627 -0.0011121125249 0)
(0.0226525090772 0.00225650709512 0)
(0.00228349984489 0.000208010775087 0)
(0.00208282129671 -8.9945262223e-06 0)
(0.0099478982467 -0.00235217538065 0)
(0.0150897757843 -0.00566775239613 0)
(0.0225977699383 -0.00899110038307 0)
(0.0273746909417 -0.00955066312282 0)
(0.0304216099936 -0.00564120474346 0)
(0.0342634727352 -0.00334554904381 0)
(0.0165885517516 -0.00109812084104 0)
(0.026820141534 -0.00304464846053 0)
(0.00364396634239 -0.000116222154316 0)
(0.00298063848618 0.000224831842898 0)
(0.00112408275245 0.000563491137044 0)
(0.000293681605243 0.000720910254337 0)
(0.000195074457098 0.00109761581888 0)
(0.000175236741625 0.00131099321625 0)
(0.00020605825435 0.00165863773901 0)
(0.000234304253982 0.00216873985758 0)
(0.000319995350375 0.00303561499286 0)
(0.000626105422258 0.00437415010484 0)
(0.00688684164245 0.00661926121609 0)
(0.00748227013956 0.0106452872219 0)
(0.024417008648 0.49391749621 0)
(0.0189421950293 0.508016510559 0)
(0.014688297425 0.504110600661 0)
(0.012579703236 0.501915095767 0)
(0.0114181999499 0.500835711418 0)
(0.0109534974168 0.500268044534 0)
(0.0109141142044 0.499923325021 0)
(0.011170406414 0.499683010108 0)
(0.0116558379846 0.499489345337 0)
(0.0123431134402 0.499309503839 0)
(0.0132318653822 0.499119279315 0)
(0.0143456829296 0.498894240513 0)
(0.015736523532 0.498601434306 0)
(0.0174948580289 0.498188376269 0)
(0.019783147893 0.497553380227 0)
(0.0228366340977 0.496509050434 0)
(0.0272680119222 0.494532750359 0)
(0.0328522519722 0.4907482772 0)
(0.0442079624982 0.481399443968 0)
(0.0547777307045 0.453513707805 0)
(0.0427382335392 0.161517279262 0)
(0.00125543667469 -0.00787874135208 0)
(-0.00116325060869 -0.00738542969518 0)
(-0.00712159397396 -0.00807516680601 0)
(-0.00594555886411 -0.00411773730585 0)
(-0.00477016062093 -0.00249653768149 0)
(-0.00387091044152 -0.00159453865388 0)
(-0.00318853070634 -0.00108093201763 0)
(-0.00267612976404 -0.00076738668078 0)
(-0.00229053584011 -0.000563752539011 0)
(-0.00194742320002 -0.000422194523516 0)
(-0.00172036313368 -0.000350929633594 0)
(-0.001533045824 -0.000315090414434 0)
(-0.00133538253691 -0.000290228595733 0)
(-0.00114713624893 -0.000278616258899 0)
(-0.000951934750702 -0.000280689254706 0)
(-0.000753952103981 -0.000295803366693 0)
(-0.000552932415585 -0.000322102402253 0)
(-0.0003184887505 -0.000338197072105 0)
(-0.000117965361247 -0.000429450743704 0)
(-1.01368367534e-05 7.3361772567e-06 0)
(2.18353924797e-05 -4.57389313548e-06 0)
(0.000621878909197 -0.000429995711173 1.96702492723e-28)
(0.00344682498839 -0.00178579872827 0)
(0.00497973524557 -0.00174420162631 0)
(0.00598618445349 -0.000784826892729 0)
(0.00616088797385 -0.000341053702077 0)
(0.00614364198765 -0.000144405721588 0)
(0.00616111676404 -3.10504214597e-05 0)
(0.00610409838242 0.000197578883621 0)
(0.005012276621 0.00172537677763 0)
(0.00532917274022 -0.000491588547969 0)
(0.0103541629363 -0.00331456616305 0)
(0.0175752441249 -0.00472005223716 0)
(0.0255064399889 -0.00440160857808 0)
(0.0309499487031 -0.00197868851447 0)
(0.0332786729184 -0.000437436835789 0)
(0.0343304852695 -0.0012392680537 0)
(0.0351199194222 -0.00296897305952 0)
(0.0366715924931 -0.000240075539775 0)
(0.035671311306 0.000735321358889 0)
(0.0349721315177 0.000877885618981 0)
(0.0372448872853 9.37847281455e-05 0)
(0.0411477947715 -5.52795815497e-05 0)
(0.0442972346223 0.000436736503687 0)
(0.0474631162824 -0.000720497665919 0)
(0.0505834149451 -0.00228712061226 0)
(0.0560346976396 -0.00436666155749 0)
(0.0619599797385 -0.0098290908897 0)
(0.0691769928276 -0.00722674210572 0)
(0.0717146369957 -0.0041916540286 0)
(0.0714617804013 -0.00138509378976 0)
(0.0700187612603 0.000855702001418 0)
(0.0681048420707 0.00246178719202 0)
(0.0656889894521 0.00387660161299 0)
(0.0624740464055 0.00553072764282 0)
(0.0580627042788 0.0078836649413 0)
(0.0509645683613 0.0125192282592 0)
(0.0466259520747 0.0257401018088 0)
(0.00541286271879 0.00723569585412 0)
(0.0189342111678 0.494065375613 0)
(0.013393258797 0.502647741046 0)
(0.00857376446502 0.501128880277 0)
(0.00672811625874 0.500486026054 0)
(0.00590585056372 0.500205173819 0)
(0.00557935992645 0.500066833468 0)
(0.0055207388878 0.499986037567 0)
(0.00563199637409 0.499930912079 0)
(0.00586855234592 0.499886990516 0)
(0.00621269135204 0.499846393237 0)
(0.00666335467984 0.499803442543 0)
(0.00723361006409 0.499752429641 0)
(0.00795328250818 0.499685542541 0)
(0.00887715917172 0.499589955191 0)
(0.0101071729734 0.499439692346 0)
(0.0118301247174 0.499182516223 0)
(0.0144988372511 0.498657320175 0)
(0.0188511550148 0.497534331451 0)
(0.029772220697 0.493953858537 0)
(0.0371027544166 0.482458064052 0)
(0.0165907569303 0.183287647375 0)
(-0.0102747043853 -0.00552759341732 0)
(-0.0541971714156 -0.0266119543762 0)
(-0.00621720783488 -0.00421656723122 0)
(-0.00913573188952 -0.00176071656322 0)
(-0.00591914507343 -0.000997147348483 0)
(-0.0044701143495 -0.000600856291502 0)
(-0.00351335537557 -0.000392488040218 0)
(-0.00286906404161 -0.000271766166299 0)
(-0.00241542653234 -0.00019608175906 0)
(-0.00203425692062 -0.00014395724158 0)
(-0.00179897678052 -0.000119390823086 0)
(-0.00160010634651 -0.000107651577554 0)
(-0.00139218010278 -9.78861980655e-05 0)
(-0.00120597995112 -9.25198587389e-05 0)
(-0.00102211716529 -9.39328473534e-05 0)
(-0.000832630732142 -0.000101613611083 0)
(-0.000632684128075 -0.000110802285217 0)
(-0.000386860305959 -0.000111448856055 0)
(-0.00019100196434 -0.000175659961912 0)
)
;
boundaryField
{
frontAndBack
{
type empty;
}
upperWall
{
type noSlip;
}
lowerWall
{
type noSlip;
}
inlet
{
type fixedValue;
value uniform (0 0.5 0);
}
outlet
{
type inletOutlet;
inletValue uniform (0 0 0);
value nonuniform List<vector>
20
(
(0.339638229969 -0.35727781721 0)
(0.464942698976 -0.298965973358 0)
(0.542252672534 -0.227562901657 0)
(0.587689796176 -0.161786544544 0)
(0.612277010439 -0.0999880894285 0)
(0.622651107901 -0.0433275459164 0)
(0.620558384731 0.0126803256907 0)
(0.609951011887 0.0578534539754 0)
(0.596109709248 0.0977865383597 0)
(0.579506320616 0.132795012758 0)
(0.560370244886 0.163906907611 0)
(0.538729619635 0.191627121965 0)
(0.514496189442 0.21638267098 0)
(0.487472642068 0.238547243885 0)
(0.457315494884 0.258512195802 0)
(0.423394900603 0.276638005628 0)
(0.384365532296 0.29318853883 0)
(0.337406815632 0.309052734726 0)
(0.278125019893 0.326377408308 0)
(0.199739521396 0.336136840125 0)
)
;
}
}
// ************************************************************************* //
| [
"as998@snu.edu.in"
] | as998@snu.edu.in | |
8a8e976d3fc0c9519d25c6391f26dfb97687f16a | d0c44dd3da2ef8c0ff835982a437946cbf4d2940 | /cmake-build-debug/programs_tiling/function14482/function14482_schedule_17/function14482_schedule_17_wrapper.cpp | d665bc80c8f4c9f1cdf510d5d3d9785b1fbed5c9 | [] | no_license | IsraMekki/tiramisu_code_generator | 8b3f1d63cff62ba9f5242c019058d5a3119184a3 | 5a259d8e244af452e5301126683fa4320c2047a3 | refs/heads/master | 2020-04-29T17:27:57.987172 | 2019-04-23T16:50:32 | 2019-04-23T16:50:32 | 176,297,755 | 1 | 2 | null | null | null | null | UTF-8 | C++ | false | false | 1,481 | cpp | #include "Halide.h"
#include "function14482_schedule_17_wrapper.h"
#include "tiramisu/utils.h"
#include <cstdlib>
#include <iostream>
#include <time.h>
#include <fstream>
#include <chrono>
#define MAX_RAND 200
int main(int, char **){
Halide::Buffer<int32_t> buf00(64, 64, 64);
Halide::Buffer<int32_t> buf01(64);
Halide::Buffer<int32_t> buf02(64, 64, 64);
Halide::Buffer<int32_t> buf03(64, 64);
Halide::Buffer<int32_t> buf04(64);
Halide::Buffer<int32_t> buf05(64, 64, 64);
Halide::Buffer<int32_t> buf06(64, 64);
Halide::Buffer<int32_t> buf07(64);
Halide::Buffer<int32_t> buf08(64, 128);
Halide::Buffer<int32_t> buf0(64, 128, 64, 64);
init_buffer(buf0, (int32_t)0);
auto t1 = std::chrono::high_resolution_clock::now();
function14482_schedule_17(buf00.raw_buffer(), buf01.raw_buffer(), buf02.raw_buffer(), buf03.raw_buffer(), buf04.raw_buffer(), buf05.raw_buffer(), buf06.raw_buffer(), buf07.raw_buffer(), buf08.raw_buffer(), buf0.raw_buffer());
auto t2 = std::chrono::high_resolution_clock::now();
std::chrono::duration<double> diff = t2 - t1;
std::ofstream exec_times_file;
exec_times_file.open("../data/programs/function14482/function14482_schedule_17/exec_times.txt", std::ios_base::app);
if (exec_times_file.is_open()){
exec_times_file << diff.count() * 1000000 << "us" <<std::endl;
exec_times_file.close();
}
return 0;
} | [
"ei_mekki@esi.dz"
] | ei_mekki@esi.dz |
81c32e2f10f0801adc0865533e57f779c2f0c17f | 0da861c2c33f4f31f0c49f08858d37584e05ac2a | /przycisk.cpp | 6df7eea84807063080038df41edb9b52fe675087 | [] | no_license | Davwidos/Rokoju_Maleras_Lite | accc8f5991ce969affcc15956f228133211dd85c | f19b18c7449e0be84e4673ddef14408262e89e18 | refs/heads/master | 2022-10-14T18:34:30.321272 | 2020-06-02T20:48:18 | 2020-06-02T20:48:18 | 268,861,907 | 0 | 3 | null | null | null | null | UTF-8 | C++ | false | false | 1,203 | cpp | #include "przycisk.h"
#include<QGraphicsTextItem>
#include<QBrush>
//tworzenie nowego przycisku
Przycisk::Przycisk(QString nazwa,QGraphicsItem *parent):QObject(),QGraphicsRectItem(parent)
{
setRect(0,0,200,100);
QBrush brush;
brush.setStyle(Qt::SolidPattern);
brush.setColor(Qt::red);
setBrush(brush);
text=new QGraphicsTextItem(nazwa,this);
int xPos = rect().width()/2 - text->boundingRect().width()/2;
int yPos = rect().height()/2 - text->boundingRect().height()/2;
text->setPos(xPos,yPos);
setAcceptHoverEvents(true);
}
//co się dzieje po kliknięciu dowolnym przyciskiem myszy w obiekt
void Przycisk::mousePressEvent(QGraphicsSceneMouseEvent *event)
{
emit clicked(text->toPlainText());
}
//co się dzieje po najechaniu kursora myszy na obiekt
void Przycisk::hoverEnterEvent(QGraphicsSceneHoverEvent *event)
{
QBrush brush;
brush.setStyle(Qt::SolidPattern);
brush.setColor(Qt::yellow);
setBrush(brush);
}
//co się dzieje po wyjściu kursora myszy poza obiekt
void Przycisk::hoverLeaveEvent(QGraphicsSceneHoverEvent *event)
{
QBrush brush;
brush.setStyle(Qt::SolidPattern);
brush.setColor(Qt::red);
setBrush(brush);
}
| [
"d.jurkowski015@gmail.com"
] | d.jurkowski015@gmail.com |
85328362cb4f766b2e7b24222c206fd2240cc5bf | d20d92c3cd617765824bb8ee3faf94c09956edca | /libraries/plugins/tags/include/delta/plugins/tags/tags_plugin.hpp | 963186af08ac31eebd81a72455d1e05e13cc8413 | [
"MIT",
"LicenseRef-scancode-warranty-disclaimer"
] | permissive | yashbhavsar007/Delta-Blockchain | 2ee003801d39708aaf6c597dff0369dec5a9c8f6 | 602dd5335d2cd51303e953e4c233c8f099da0b07 | refs/heads/master | 2020-07-03T22:42:40.141910 | 2019-08-13T07:13:54 | 2019-08-13T07:13:54 | 202,075,688 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 15,675 | hpp | #pragma once
#include <delta/plugins/chain/chain_plugin.hpp>
#include <delta/chain/comment_object.hpp>
#include <boost/multi_index/composite_key.hpp>
namespace delta { namespace plugins { namespace tags {
using namespace delta::chain;
using namespace boost::multi_index;
using namespace appbase;
using chainbase::object;
using chainbase::oid;
using chainbase::allocator;
//
// Plugins should #define their SPACE_ID's so plugins with
// conflicting SPACE_ID assignments can be compiled into the
// same binary (by simply re-assigning some of the conflicting #defined
// SPACE_ID's in a build script).
//
// Assignment of SPACE_ID's cannot be done at run-time because
// various template automagic depends on them being known at compile
// time.
//
#ifndef DELTA_TAG_SPACE_ID
#define DELTA_TAG_SPACE_ID 5
#endif
#define DELTA_TAGS_PLUGIN_NAME "tags"
typedef protocol::fixed_string< 32 > tag_name_type;
// Plugins need to define object type IDs such that they do not conflict
// globally. If each plugin uses the upper 8 bits as a space identifier,
// with 0 being for chain, then the lower 8 bits are free for each plugin
// to define as they see fit.
enum
{
tag_object_type = ( DELTA_TAG_SPACE_ID << 8 ),
tag_stats_object_type = ( DELTA_TAG_SPACE_ID << 8 ) + 1,
peer_stats_object_type = ( DELTA_TAG_SPACE_ID << 8 ) + 2,
author_tag_stats_object_type = ( DELTA_TAG_SPACE_ID << 8 ) + 3
};
namespace detail { class tags_plugin_impl; }
/**
* The purpose of the tag object is to allow the generation and listing of
* all top level posts by a string tag. The desired sort orders include:
*
* 1. created - time of creation
* 2. maturing - about to receive a payout
* 3. active - last reply the post or any child of the post
* 4. netvotes - individual accounts voting for post minus accounts voting against it
*
* When ever a comment is modified, all tag_objects for that comment are updated to match.
*/
class tag_object : public object< tag_object_type, tag_object >
{
public:
template< typename Constructor, typename Allocator >
tag_object( Constructor&& c, allocator< Allocator > a )
{
c( *this );
}
tag_object() {}
id_type id;
tag_name_type tag;
time_point_sec created;
time_point_sec active;
time_point_sec cashout;
int64_t net_rshares = 0;
int32_t net_votes = 0;
int32_t children = 0;
double hot = 0;
double trending = 0;
share_type promoted_balance = 0;
account_id_type author;
comment_id_type parent;
comment_id_type comment;
bool is_post()const { return parent == comment_id_type(); }
};
typedef oid< tag_object > tag_id_type;
struct by_cashout; /// all posts regardless of depth
struct by_parent_created;
struct by_parent_active;
struct by_parent_promoted;
struct by_parent_net_votes; /// all top level posts by direct votes
struct by_parent_trending;
struct by_parent_children; /// all top level posts with the most discussion (replies at all levels)
struct by_parent_hot;
struct by_author_comment;
struct by_reward_fund_net_rshares;
struct by_comment;
struct by_tag;
typedef multi_index_container<
tag_object,
indexed_by<
ordered_unique< tag< by_id >, member< tag_object, tag_id_type, &tag_object::id > >,
ordered_unique< tag< by_comment >,
composite_key< tag_object,
member< tag_object, comment_id_type, &tag_object::comment >,
member< tag_object, tag_id_type, &tag_object::id >
>,
composite_key_compare< std::less< comment_id_type >, std::less< tag_id_type > >
>,
ordered_unique< tag< by_author_comment >,
composite_key< tag_object,
member< tag_object, account_id_type, &tag_object::author >,
member< tag_object, comment_id_type, &tag_object::comment >,
member< tag_object, tag_id_type, &tag_object::id >
>,
composite_key_compare< std::less< account_id_type >, std::less< comment_id_type >, std::less< tag_id_type > >
>,
ordered_unique< tag< by_parent_created >,
composite_key< tag_object,
member< tag_object, tag_name_type, &tag_object::tag >,
member< tag_object, comment_id_type, &tag_object::parent >,
member< tag_object, time_point_sec, &tag_object::created >,
member<tag_object, tag_id_type, &tag_object::id >
>,
composite_key_compare< std::less< tag_name_type >, std::less<comment_id_type>, std::greater< time_point_sec >, std::less< tag_id_type > >
>,
ordered_unique< tag< by_parent_active >,
composite_key< tag_object,
member< tag_object, tag_name_type, &tag_object::tag >,
member< tag_object, comment_id_type, &tag_object::parent >,
member< tag_object, time_point_sec, &tag_object::active >,
member< tag_object, tag_id_type, &tag_object::id >
>,
composite_key_compare< std::less<tag_name_type>, std::less<comment_id_type>, std::greater< time_point_sec >, std::less< tag_id_type > >
>,
ordered_unique< tag< by_parent_promoted >,
composite_key< tag_object,
member< tag_object, tag_name_type, &tag_object::tag >,
member< tag_object, comment_id_type, &tag_object::parent >,
member< tag_object, share_type, &tag_object::promoted_balance >,
member< tag_object, tag_id_type, &tag_object::id >
>,
composite_key_compare< std::less<tag_name_type>, std::less<comment_id_type>, std::greater< share_type >, std::less< tag_id_type > >
>,
ordered_unique< tag< by_parent_net_votes >,
composite_key< tag_object,
member< tag_object, tag_name_type, &tag_object::tag >,
member< tag_object, comment_id_type, &tag_object::parent >,
member< tag_object, int32_t, &tag_object::net_votes >,
member< tag_object, tag_id_type, &tag_object::id >
>,
composite_key_compare< std::less<tag_name_type>, std::less<comment_id_type>, std::greater< int32_t >, std::less< tag_id_type > >
>,
ordered_unique< tag< by_parent_children >,
composite_key< tag_object,
member< tag_object, tag_name_type, &tag_object::tag >,
member< tag_object, comment_id_type, &tag_object::parent >,
member< tag_object, int32_t, &tag_object::children >,
member< tag_object, tag_id_type, &tag_object::id >
>,
composite_key_compare< std::less<tag_name_type>, std::less<comment_id_type>, std::greater< int32_t >, std::less< tag_id_type > >
>,
ordered_unique< tag< by_parent_hot >,
composite_key< tag_object,
member< tag_object, tag_name_type, &tag_object::tag >,
member< tag_object, comment_id_type, &tag_object::parent >,
member< tag_object, double, &tag_object::hot >,
member< tag_object, tag_id_type, &tag_object::id >
>,
composite_key_compare< std::less<tag_name_type>, std::less<comment_id_type>, std::greater< double >, std::less< tag_id_type > >
>,
ordered_unique< tag< by_parent_trending >,
composite_key< tag_object,
member< tag_object, tag_name_type, &tag_object::tag >,
member< tag_object, comment_id_type, &tag_object::parent >,
member< tag_object, double, &tag_object::trending >,
member< tag_object, tag_id_type, &tag_object::id >
>,
composite_key_compare< std::less<tag_name_type>, std::less<comment_id_type>, std::greater< double >, std::less< tag_id_type > >
>,
ordered_unique< tag< by_cashout >,
composite_key< tag_object,
member< tag_object, tag_name_type, &tag_object::tag >,
member< tag_object, time_point_sec, &tag_object::cashout >,
member< tag_object, tag_id_type, &tag_object::id >
>,
composite_key_compare< std::less<tag_name_type>, std::less< time_point_sec >, std::less< tag_id_type > >
>,
ordered_unique< tag< by_reward_fund_net_rshares >,
composite_key< tag_object,
member< tag_object, tag_name_type, &tag_object::tag >,
const_mem_fun< tag_object, bool, &tag_object::is_post >,
member< tag_object, int64_t, &tag_object::net_rshares >,
member< tag_object, tag_id_type, &tag_object::id >
>,
composite_key_compare< std::less<tag_name_type>, std::less< bool >,std::greater< int64_t >, std::less< tag_id_type > >
>
>,
allocator< tag_object >
> tag_index;
/**
* The purpose of this index is to quickly identify how popular various tags by maintaining variou sums over
* all posts under a particular tag
*/
class tag_stats_object : public object< tag_stats_object_type, tag_stats_object >
{
public:
template< typename Constructor, typename Allocator >
tag_stats_object( Constructor&& c, allocator< Allocator > )
{
c( *this );
}
tag_stats_object() {}
id_type id;
tag_name_type tag;
asset total_payout = asset( 0, DBD_SYMBOL );
int32_t net_votes = 0;
uint32_t top_posts = 0;
uint32_t comments = 0;
fc::uint128 total_trending = 0;
};
typedef oid< tag_stats_object > tag_stats_id_type;
struct by_comments;
struct by_top_posts;
struct by_trending;
typedef multi_index_container<
tag_stats_object,
indexed_by<
ordered_unique< tag< by_id >, member< tag_stats_object, tag_stats_id_type, &tag_stats_object::id > >,
ordered_unique< tag< by_tag >, member< tag_stats_object, tag_name_type, &tag_stats_object::tag > >,
/*
ordered_non_unique< tag< by_comments >,
composite_key< tag_stats_object,
member< tag_stats_object, uint32_t, &tag_stats_object::comments >,
member< tag_stats_object, tag_name_type, &tag_stats_object::tag >
>,
composite_key_compare< std::less< tag_name_type >, std::greater< uint32_t > >
>,
ordered_non_unique< tag< by_top_posts >,
composite_key< tag_stats_object,
member< tag_stats_object, uint32_t, &tag_stats_object::top_posts >,
member< tag_stats_object, tag_name_type, &tag_stats_object::tag >
>,
composite_key_compare< std::less< tag_name_type >, std::greater< uint32_t > >
>,
*/
ordered_non_unique< tag< by_trending >,
composite_key< tag_stats_object,
member< tag_stats_object, fc::uint128 , &tag_stats_object::total_trending >,
member< tag_stats_object, tag_name_type, &tag_stats_object::tag >
>,
composite_key_compare< std::greater< fc::uint128 >, std::less< tag_name_type > >
>
>,
allocator< tag_stats_object >
> tag_stats_index;
/**
* This purpose of this object is to maintain stats about which tags an author uses, how frequnetly, and
* how many total earnings of all posts by author in tag. It also allows us to answer the question of which
* authors earn the most in each tag category. This helps users to discover the best bloggers to follow for
* particular tags.
*/
class author_tag_stats_object : public object< author_tag_stats_object_type, author_tag_stats_object >
{
public:
template< typename Constructor, typename Allocator >
author_tag_stats_object( Constructor&& c, allocator< Allocator > )
{
c( *this );
}
id_type id;
account_id_type author;
tag_name_type tag;
asset total_rewards = asset( 0, DBD_SYMBOL );
uint32_t total_posts = 0;
};
typedef oid< author_tag_stats_object > author_tag_stats_id_type;
struct by_author_tag_posts;
struct by_author_posts_tag;
using std::less;
using std::greater;
typedef chainbase::shared_multi_index_container<
author_tag_stats_object,
indexed_by<
ordered_unique< tag< by_id >,
member< author_tag_stats_object, author_tag_stats_id_type, &author_tag_stats_object::id >
>,
ordered_unique< tag< by_author_posts_tag >,
composite_key< author_tag_stats_object,
member< author_tag_stats_object, account_id_type, &author_tag_stats_object::author >,
member< author_tag_stats_object, uint32_t, &author_tag_stats_object::total_posts >,
member< author_tag_stats_object, tag_name_type, &author_tag_stats_object::tag >
>,
composite_key_compare< less< account_id_type >, greater< uint32_t >, less< tag_name_type > >
>,
ordered_unique< tag< by_author_tag_posts >,
composite_key< author_tag_stats_object,
member< author_tag_stats_object, account_id_type, &author_tag_stats_object::author >,
member< author_tag_stats_object, tag_name_type, &author_tag_stats_object::tag >,
member< author_tag_stats_object, uint32_t, &author_tag_stats_object::total_posts >
>,
composite_key_compare< less< account_id_type >, less< tag_name_type >, greater< uint32_t > >
>
>
> author_tag_stats_index;
/**
* Used to parse the metadata from the comment json_meta field.
*/
struct comment_metadata { set<string> tags; };
/**
* This plugin will scan all changes to posts and/or their meta data and
*
*/
class tags_plugin : public plugin< tags_plugin >
{
public:
tags_plugin();
virtual ~tags_plugin();
APPBASE_PLUGIN_REQUIRES( (delta::plugins::chain::chain_plugin) )
static const std::string& name() { static std::string name = DELTA_TAGS_PLUGIN_NAME; return name; }
virtual void set_program_options(
options_description& cli,
options_description& cfg) override;
virtual void plugin_initialize( const variables_map& options ) override;
virtual void plugin_startup() override;
virtual void plugin_shutdown() override;
friend class detail::tags_plugin_impl;
private:
std::unique_ptr< detail::tags_plugin_impl > my;
};
/**
* This API is used to query data maintained by the tags_plugin
*/
/*
class tag_api : public std::enable_shared_from_this<tag_api> {
public:
tag_api(){};
tag_api(const app::api_context& ctx){}//:_app(&ctx.app){}
void on_api_startup(){
}
vector<tag_stats_object> get_tags()const { return vector<tag_stats_object>(); }
private:
//app::application* _app = nullptr;
};
*/
} } } //delta::plugins::tags
FC_REFLECT( delta::plugins::tags::tag_object,
(id)(tag)(created)(active)(cashout)(net_rshares)(net_votes)(hot)(trending)(promoted_balance)(children)(author)(parent)(comment) )
CHAINBASE_SET_INDEX_TYPE( delta::plugins::tags::tag_object, delta::plugins::tags::tag_index )
FC_REFLECT( delta::plugins::tags::tag_stats_object,
(id)(tag)(total_payout)(net_votes)(top_posts)(comments)(total_trending) );
CHAINBASE_SET_INDEX_TYPE( delta::plugins::tags::tag_stats_object, delta::plugins::tags::tag_stats_index )
FC_REFLECT( delta::plugins::tags::comment_metadata, (tags) );
FC_REFLECT( delta::plugins::tags::author_tag_stats_object, (id)(author)(tag)(total_posts)(total_rewards) )
CHAINBASE_SET_INDEX_TYPE( delta::plugins::tags::author_tag_stats_object, delta::plugins::tags::author_tag_stats_index )
| [
"yashbhavsar.yb@gmail.com"
] | yashbhavsar.yb@gmail.com |
0b319f25c399004772ed0d9480994b60cf783ff3 | 41c3abcf69ad799dce3c89ada913bb3823f11f9d | /src/bootmanager.cpp | ef3ea53340fa883d66700a5ba22e8f0cb68344fa | [
"MIT"
] | permissive | Tpimp/OdroidFlashTool | 8f79fc9f7839de0426a59b0e66edce0f7444b984 | 073acf19bcd81a2c2df95142b4c759fb58d812da | refs/heads/master | 2022-04-30T21:02:56.535391 | 2022-04-25T15:52:35 | 2022-04-25T15:52:35 | 58,492,931 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 91 | cpp | #include "bootmanager.h"
BootManager::BootManager(QObject *parent) : QObject(parent)
{
}
| [
"christopher.dean@oit.edu"
] | christopher.dean@oit.edu |
8878d6e933d34dfd68d69f9eff830999f0d98b73 | 190c2dc8dd46fa83060794b7941f83e83bd6c90c | /AOJ/0001/ListOfTop3Hills.cc | dab689e2db71d8c26412ed3d8eab66d5074e80fd | [] | no_license | yku/Competition | 85ce169342e12c28e6d8dca8b78e00be1786403f | 892046f3e80fe3d30fa12ca77f5cbba2d0c764fa | refs/heads/master | 2020-05-20T08:14:01.912818 | 2014-04-13T05:28:26 | 2014-04-13T05:28:26 | 2,637,428 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 333 | cc | #include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main()
{
vector<int> hills;
int hill;
while(cin >> hill) {
hills.push_back(hill);
}
sort(hills.begin(), hills.end(), greater<int>());
for(int i = 0; i < 3; i++)
cout << hills[i] << endl;
return 0;
}
| [
"kz2yz4@gmail.com"
] | kz2yz4@gmail.com |
9f3d38a5aac763aa2e18f7779b15b5d41551b499 | f1533c3b39e8f2e1d9dc8790a8fbd0c485d544e9 | /stringsum_self.cpp | 326e33b72b0fe44f347d007cf086e4b7d774b1a5 | [] | no_license | sweetyburnwal/Coding-Block | 953cffe9ca0c51f72d77bf5e13a13fa2ffb62418 | 23ed1e23091ba66dc1daefa3861e71948b14999c | refs/heads/master | 2020-12-26T18:40:41.626354 | 2020-02-01T10:55:47 | 2020-02-01T10:55:47 | 237,599,582 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 223 | cpp | #include<iostream>
#include<cstring>
using namespace std;
int main()
{
string s1="sweety";
string s2="burnwal";
cout<<s1+s2<<endl;
//only addition takes place here,no substraction,multiplication or division
}
| [
"sweetyburnwal013@gmail.com"
] | sweetyburnwal013@gmail.com |
edf00680ad71f34e3f00ed796047bfa03c7e7947 | 8d08d99be7f750684483badc13ef87d13a44baec | /source/LibFgWin/FgGuiWinTabs.cpp | c914f86f50b30f2b96e182d0874ebeb2203a7c89 | [
"MIT"
] | permissive | denim2x/FaceGenBaseLibrary | de29421ab03a2076e645ac2d279eead5ac07ec20 | 52317cf96984a47d7f2d0c5471230d689404101c | refs/heads/master | 2020-09-09T18:45:15.306511 | 2019-11-15T13:38:21 | 2019-11-15T13:38:21 | 221,531,686 | 0 | 0 | MIT | 2019-11-13T19:04:24 | 2019-11-13T19:04:23 | null | UTF-8 | C++ | false | false | 7,932 | cpp | //
// Copyright (c) 2019 Singular Inversions Inc. (facegen.com)
// Use, modification and distribution is subject to the MIT License,
// see accompanying file LICENSE.txt or facegen.com/base_library_license.txt
//
//
// Win32 has no way to dynamically change the background color of specific tabs (ie currently selected).
// The only way to do this is to override the default WM_ERASEBKGND and WM_PAINT and draw them yourself.
// At which point you may as well implement your own tabs.
#include "stdafx.h"
#include "FgGuiApiTabs.hpp"
#include "FgGuiWin.hpp"
#include "FgThrowWindows.hpp"
#include "FgMatrixC.hpp"
#include "FgBounds.hpp"
#include "FgMetaFormat.hpp"
using namespace std;
namespace Fg {
struct GuiTabsWin : public GuiBaseImpl
{
GuiTabs m_api;
HWND m_tabHwnd;
HWND hwndThis;
GuiImplPtrs m_panes;
uint m_currPane;
Vec2I m_client;
RECT m_dispArea;
Ustring m_store;
GuiTabsWin(const GuiTabs & api)
: m_api(api)
{
FGASSERT(m_api.tabs.size()>0);
for (size_t ii=0; ii<m_api.tabs.size(); ++ii)
m_panes.push_back(api.tabs[ii].win->getInstance());
m_currPane = 0;
}
virtual void
create(HWND parentHwnd,int ident,const Ustring & store,DWORD extStyle,bool visible)
{
//fgout << fgnl << "Tabs::create visible: " << visible << " extStyle: " << extStyle << fgpush;
m_store = store;
uint cp;
if (fgLoadXml(m_store+".xml",cp,false))
if (cp < m_panes.size())
m_currPane = cp;
WinCreateChild cc;
cc.extStyle = extStyle;
cc.visible = visible;
winCreateChild(parentHwnd,ident,this,cc);
//fgout << fgpop;
}
virtual void
destroy()
{
// Automatically destroys children first:
DestroyWindow(hwndThis);
}
virtual Vec2UI
getMinSize() const
{
Vec2UI max(0);
for (size_t ii=0; ii<m_panes.size(); ++ii) {
const GuiTabDef & tab = m_api.tabs[ii];
Vec2UI pad(tab.padLeft+tab.padRight,tab.padTop+tab.padBottom);
max = cMax(max,m_panes[ii]->getMinSize()+pad);
}
return max + Vec2UI(0,37);
}
virtual Vec2B
wantStretch() const
{
for (size_t ii=0; ii<m_panes.size(); ++ii)
if (m_panes[ii]->wantStretch()[0])
return Vec2B(true,true);
return Vec2B(false,true);
}
virtual void
updateIfChanged()
{
//fgout << fgnl << "Tabs::updateIfChanged" << fgpush;
m_panes[m_currPane]->updateIfChanged();
//fgout << fgpop;
}
virtual void
moveWindow(Vec2I lo,Vec2I sz)
{
//fgout << fgnl << "Tabs::moveWindow " << lo << "," << sz << fgpush;
MoveWindow(hwndThis,lo[0],lo[1],sz[0],sz[1],FALSE);
//fgout << fgpop;
}
virtual void
showWindow(bool s)
{
//fgout << fgnl << "Tabs::showWindow: " << s << fgpush;
ShowWindow(hwndThis,s ? SW_SHOW : SW_HIDE);
//fgout << fgpop;
}
virtual void
saveState()
{
fgSaveXml(m_store+".xml",m_currPane,false);
for (size_t ii=0; ii<m_panes.size(); ++ii)
m_panes[ii]->saveState();
}
LRESULT
wndProc(HWND hwnd,UINT msg,WPARAM wParam,LPARAM lParam)
{
if (msg == WM_CREATE) {
//fgout << fgnl << "Tabs::WM_CREATE" << fgpush;
hwndThis = hwnd;
// Creating the panes before the tabs fixes the problem of trackbars not being visible
// on first paint (almost ... top/bottom arrows don't appear). No idea why.
for (size_t ii=0; ii<m_panes.size(); ++ii) {
// Set visibility here to avoid sending 'ShowWindow' messages, which also
// send WM_SIZE. The sizing will all be done after creation when ShowWindow
// is called from the client level.
m_panes[ii]->create(hwnd,
int(ii+1), // Child identifiers start at 1 since 0 taken above. Not used anyway.
m_store+"_"+toString(ii),
NULL,
ii==m_currPane);
}
m_tabHwnd =
CreateWindowEx(0,
WC_TABCONTROL,
L"",
WS_CHILD | WS_VISIBLE,
0,0,0,0,
hwnd,
0, // Identifier 0
s_guiWin.hinst,
NULL);
TCITEM tc = {0};
tc.mask = TCIF_TEXT;
for (size_t ii=0; ii<m_panes.size(); ++ii) {
wstring wstr = m_api.tabs[ii].label.as_wstring();
wstr += wchar_t(0);
tc.pszText = &wstr[0];
TabCtrl_InsertItem(m_tabHwnd,ii,&tc);
}
SendMessage(m_tabHwnd,TCM_SETCURSEL,m_currPane,0);
if (m_api.tabs[m_currPane].onSelect != NULL)
m_api.tabs[m_currPane].onSelect();
//fgout << fgpop;
return 0;
}
else if (msg == WM_SIZE) {
m_client = Vec2I(LOWORD(lParam),HIWORD(lParam));
if (m_client[0] * m_client[1] > 0) {
//fgout << fgnl << "Tabs::WM_SIZE: " << m_api.tabs[0].label << " : " << m_client << fgpush;
resize(hwnd);
//fgout << fgpop;
}
return 0;
}
else if (msg == WM_NOTIFY) {
LPNMHDR lpnmhdr = (LPNMHDR)lParam;
if (lpnmhdr->code == TCN_SELCHANGE) {
int idx = int(SendMessage(m_tabHwnd,TCM_GETCURSEL,0,0));
// This can apparently be -1 for 'no tab selected':
if ((idx >= 0) && (size_t(idx) < m_panes.size())) {
//fgout << fgnl << "Tabs::WM_NOTIFY: " << idx << fgpush;
if (uint(idx) != m_currPane) {
m_panes[m_currPane]->showWindow(false);
m_currPane = uint(idx);
// Must do update check and resize since these are not done when the
// tab is not visible:
m_panes[m_currPane]->updateIfChanged();
resizeCurrPane();
m_panes[m_currPane]->showWindow(true);
if (m_api.tabs[m_currPane].onSelect != NULL)
m_api.tabs[m_currPane].onSelect();
InvalidateRect(hwndThis,NULL,TRUE);
}
//fgout << fgpop;
}
}
return 0;
}
else if (msg == WM_PAINT) {
//fgout << fgnl << "Tabs::WM_PAINT";
}
return DefWindowProc(hwnd,msg,wParam,lParam);
}
void
resizeCurrPane()
{
const GuiTabDef & tab = m_api.tabs[m_currPane];
Vec2I lo(m_dispArea.left + tab.padLeft, m_dispArea.top + tab.padTop),
hi(m_dispArea.right - tab.padRight,m_dispArea.bottom - tab.padBottom),
sz = hi - lo;
m_panes[m_currPane]->moveWindow(lo,sz);
}
void
resize(HWND)
{
MoveWindow(m_tabHwnd,0,0,m_client[0],m_client[1],FALSE);
m_dispArea.left = 0;
m_dispArea.top = 0;
m_dispArea.right = m_client[0];
m_dispArea.bottom = m_client[1];
SendMessage(m_tabHwnd,
TCM_ADJUSTRECT,
NULL, // Give me the display area for this window area:
LPARAM(&m_dispArea));
resizeCurrPane();
}
};
GuiImplPtr
guiGetOsImpl(const GuiTabs & api)
{return GuiImplPtr(new GuiTabsWin(api)); }
}
| [
"abeatty@facegen.com"
] | abeatty@facegen.com |
a680fe0167eddaf7ad168a07164b617a168cb924 | 2ae89c958b908a6b44ac6c8d483f2df0c49f8cfa | /lib/parse/ASTVisitor.h | 0bf5b862373fe29071dfcd74dfdb8240b791eca6 | [
"MIT"
] | permissive | lukaskollmer/yo | 59b9116b0a99c0839e5c8e69dda873703b8970e2 | 38e6c646f96512c31ced8ab828382fc5021cff97 | refs/heads/master | 2021-01-19T10:04:46.902162 | 2020-04-04T19:49:06 | 2020-04-04T19:49:06 | 87,804,824 | 11 | 0 | MIT | 2020-02-07T17:02:03 | 2017-04-10T11:49:42 | C++ | UTF-8 | C++ | false | false | 304 | h | //
// ASTVisitor.h
// yo
//
// Created by Lukas Kollmer on 2020-03-05.
// Copyright © 2019 Lukas Kollmer. All rights reserved.
//
#pragma once
#include "AST.h"
#include <string>
namespace yo::ast {
// TODO implement the visitor properly!!
void print_ast(const ast::AST&);
} // ns yo::ast
| [
"me@lukaskollmer.de"
] | me@lukaskollmer.de |
bbe4759e0ca522bb4acbd13b6de120de620f63ad | 9c761f8b7ed3b4b329e6c71920dc39fa5995d492 | /Game/Enemy.h | 915c4d8d7226a00d6cfc9195eeaa9158fe2b8003 | [] | no_license | AlexLimbrick/Text-Adventure | 895479dbf5097c96d5be2fdccefd27bcdb43b469 | 5a787913c3d06f7425658e380eff1cbb9ad18f69 | refs/heads/master | 2020-05-31T12:02:21.205678 | 2019-06-04T20:03:40 | 2019-06-04T20:03:40 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 782 | h | #pragma once
#include <iostream>
#include <stdlib.h>
#include <string>
#include "Potion.h"
using namespace std;
class Enemy
{
public:
Enemy(int _ac = 14, int _health = 10, int _damage = 2, int _attack = 2, int _potiontype = 1, string _name = "hi", bool _alive = true);
Enemy(const Enemy& _copyEnemy);
Enemy& operator=(const Enemy& _copyEnemy);
~Enemy();
int MyChoice();
int Attack();
void UsePotion();
string GetName() { return name; }
void Hit(int _damage);
void Kill();
int GetAC()const { return ac; }
bool IsAlive() const { return alive; }
int GetDam() const { return damage; }
protected:
static int enemyCount;
int health;
int ac;
int attack;
int damage;
int roll;
bool alive ;
int potionType;// 1 = light 2 = moderate
string name;
Potion potion;
};
| [
"alexlimbrick33@gmail.com"
] | alexlimbrick33@gmail.com |
0879d46ae2b0ca4513814cf913bf063546fe6745 | 1faed4e4660e73dd120d10fa6c56451332080cbf | /123234345/3630/6148208_WA.cc | 495eaf8fb6e3559a1c620fd9f05bf21932772478 | [] | no_license | zizhong/POJSolutions | 856b05dd3fd4d5c6114fa2af23b144d8b624d566 | 096029f8e6d4de17ab8c6914da06f54ac5a6fd82 | refs/heads/master | 2021-01-02T22:45:49.449068 | 2013-10-01T07:55:17 | 2013-10-01T07:55:17 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 987 | cc | #include<stdio.h>
#include<string.h>
const int N=10000;
struct Trie
{
int mark;
Trie *next[10];
}head,node[10*N];
int pos;
void build_trie()
{
head.mark=pos=0;
memset(head.next,0,sizeof(head.next));
}
int insert(char *s)
{
Trie *st=&head;
int i=0,n=strlen(s);
for(;i<n;i++)
{
int key=s[i]-'0';
if(st->mark) return 0;
if(st->next[key]==0) break;
st=st->next[key];
}
if(i==n) return 0;
for(;i<n;i++)
{
Trie *nw=&node[pos++];
memset(nw,0,sizeof(nw));
st->next[s[i]-'0']=nw;
st=nw;
}
return st->mark=1;
}
int main()
{
int T;
scanf("%d",&T);
while(T--)
{
int n;
scanf("%d",&n);
char s[11];
build_trie();
gets(s);
int flag=1;
while(n--)
{
gets(s);
if(flag) flag=insert(s);//,printf("%d\n",flag);
}
puts(flag?"YES":"NO");
}
}
| [
"zhangzizhong0828@gmail.com"
] | zhangzizhong0828@gmail.com |
7f57e38c2546bdf2673b5d42ded3055745897c24 | cb151d45854da971c065f2bb1e7cee633b840110 | /CLRBridge/Stdafx.cpp | 138e896bed34ebb939f258ee59b708e58312e93f | [
"BSD-3-Clause"
] | permissive | TWinsnes/MFC-CSharp | 3107e93e55e34284539b6d3eb848bb900190c43d | 8430eab2d0b407024290fcfb825cfdf52888dd1c | refs/heads/master | 2016-09-05T16:38:42.634895 | 2013-04-15T13:30:53 | 2013-04-15T13:30:53 | 9,448,183 | 0 | 2 | null | null | null | null | UTF-8 | C++ | false | false | 200 | cpp | // stdafx.cpp : source file that includes just the standard includes
// CLRBridge.pch will be the pre-compiled header
// stdafx.obj will contain the pre-compiled type information
#include "stdafx.h"
| [
"Thomas@ideadrought.com"
] | Thomas@ideadrought.com |
75db46a7fde9924a5f47e8adbed9eaf1795e5b36 | def39f068050b234df9f6909d4277f96b740f11c | /E-olimp/1685. Earth Antarctica .cpp | 0f2b837ad647d0fa310724ee75fb2dfa3ea77d41 | [] | no_license | azecoder/Problem-Solving | 41a9a4302c48c8de59412ab9175b253df99f1f28 | a920b7bac59830c7b798127f6eed0e2ab31a5fa2 | refs/heads/master | 2023-02-10T09:47:48.322849 | 2021-01-05T14:14:09 | 2021-01-05T14:14:09 | 157,236,604 | 5 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 1,370 | cpp | #include <cstdlib>
#include <iostream>
#include <queue>
using namespace std;
long n,k,B[10000],D[10000],sum=0,v,a[1000],b[1000],c[1000][1000],max1;
int main(int argc, char *argv[])
{
queue <int> s;
cin>>n;
max1=0;
for(int i=1;i<=n;i++){
cin>>a[i]>>b[i];
c[a[i]][b[i]]=i;
}
memset(B,0,sizeof(B));
k=0;
while(1){
k=0;
for(int i=1;i<=n;i++)
if(B[i]==0){k=1; v=i; s.push(v);break;}
if(k==0)break; else sum++;
while(!s.empty() ){
v=s.front();
B[v]=1;
s.pop();
if(!B[c[a[v]][b[v]-1]] && c[a[v]][b[v]-1])s.push(c[a[v]][b[v]-1]);
if(!B[c[a[v]][b[v]+1]] && c[a[v]][b[v]+1])s.push(c[a[v]][b[v]+1]);
if(!B[c[a[v]+1][b[v]-1]] && c[a[v]+1][b[v]-1])s.push(c[a[v]+1][b[v]-1]);
if(!B[c[a[v]-1][b[v]-1]] && c[a[v]-1][b[v]-1])s.push(c[a[v]-1][b[v]-1]);
if(!B[c[a[v]+1][b[v]]] && c[a[v]+1][b[v]])s.push(c[a[v]+1][b[v]]);
if(!B[c[a[v]-1][b[v]]] && c[a[v]-1][b[v]])s.push(c[a[v]-1][b[v]]);
if(!B[c[a[v]+1][b[v]+1]] && c[a[v]+1][b[v]+1])s.push(c[a[v]+1][b[v]+1]);
if(!B[c[a[v]-1][b[v]+1]] && c[a[v]-1][b[v]+1])s.push(c[a[v]-1][b[v]+1]);
}
}
cout<<sum<<endl;
return EXIT_SUCCESS;
} | [
"tabriz.haji@gmail.com"
] | tabriz.haji@gmail.com |
5f0df272e23f6abb93061cb591dfee9e52bb25bb | a23665259e3b931a12290d5ff80e1c4d4916c0ea | /cl_dll/c_baseanimating.cpp | e6f2d53fb107711278ed7e5be6b751c2b433365d | [] | no_license | q4a/half | 507490107968459073f23c306bdff56e7dffd9f7 | 6a4302e286aa5bfd9ebdc7ed2688d2290981ec9c | refs/heads/master | 2022-04-26T13:18:15.597053 | 2017-06-15T13:32:34 | 2017-06-15T13:32:34 | null | 0 | 0 | null | null | null | null | WINDOWS-1252 | C++ | false | false | 77,281 | cpp | //========= Copyright © 1996-2001, Valve LLC, All rights reserved. ============
//
// Purpose:
//
// $NoKeywords: $
//=============================================================================
#include "cbase.h"
#include "c_baseanimating.h"
#include "c_Sprite.h"
#include "model_types.h"
#include "bone_setup.h"
#include "ivrenderview.h"
#include "r_efx.h"
#include "dlight.h"
#include "beamdraw.h"
#include "cl_animevent.h"
#include "engine/IEngineSound.h"
#include "c_te_legacytempents.h"
#include "c_clientstats.h"
#include "activitylist.h"
#include "animation.h"
#include "tier0/vprof.h"
#include "ClientEffectPrecacheSystem.h"
#include "ieffects.h"
#include "engine/ivmodelinfo.h"
#include "engine/IVDebugOverlay.h"
#include "c_te_effect_dispatch.h"
#include <KeyValues.h>
#include "c_rope.h"
#include "isaverestore.h"
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
static ConVar r_drawmrmmodels( "r_drawmrmmodels", "1" );
static ConVar r_drawvehicles( "r_drawvehicles", "1" );
// Removed macro used by shared code stuff
#if defined( CBaseAnimating )
#undef CBaseAnimating
#endif
CLIENTEFFECT_REGISTER_BEGIN( PrecacheBaseAnimating )
CLIENTEFFECT_MATERIAL( "sprites/fire" )
CLIENTEFFECT_REGISTER_END()
BEGIN_RECV_TABLE_NOBASE( C_BaseAnimating, DT_ServerAnimationData )
RecvPropFloat(RECVINFO(m_flCycle)),
END_RECV_TABLE()
IMPLEMENT_CLIENTCLASS_DT(C_BaseAnimating, DT_BaseAnimating, CBaseAnimating)
RecvPropInt(RECVINFO(m_nSequence)),
RecvPropInt(RECVINFO(m_nForceBone)),
RecvPropVector(RECVINFO(m_vecForce)),
RecvPropInt(RECVINFO(m_nSkin)),
RecvPropInt(RECVINFO(m_nBody)),
RecvPropInt(RECVINFO(m_nHitboxSet)),
RecvPropFloat(RECVINFO(m_flModelScale)),
RecvPropArray(RecvPropFloat(RECVINFO(m_flPoseParameter[0])), m_flPoseParameter),
RecvPropFloat(RECVINFO(m_flPlaybackRate)),
RecvPropArray(RecvPropFloat(RECVINFO(m_flEncodedController[0])), m_flEncodedController),
RecvPropInt( RECVINFO( m_bClientSideAnimation )),
RecvPropInt( RECVINFO( m_bClientSideFrameReset )),
RecvPropInt( RECVINFO( m_nNewSequenceParity )),
RecvPropInt( RECVINFO( m_nResetEventsParity )),
RecvPropDataTable( "serveranimdata", 0, 0, &REFERENCE_RECV_TABLE( DT_ServerAnimationData ) ),
END_RECV_TABLE()
// Incremented each frame in InvalidateModelBones. Models compare this value to what it
// was last time they setup their bones to determine if they need to re-setup their bones.
static unsigned long g_iModelBoneCounter = 0;
//-----------------------------------------------------------------------------
// Purpose: convert axis rotations to a quaternion
//-----------------------------------------------------------------------------
C_BaseAnimating::C_BaseAnimating()
{
#ifdef _DEBUG
m_vecForce.Init();
#endif
m_nPrevSequence = -1;
m_nRestoreSequence = -1;
m_pRagdoll = NULL;
m_builtRagdoll = false;
int i;
for ( i = 0; i < ARRAYSIZE( m_flEncodedController ); i++ )
{
m_flEncodedController[ i ] = 0.0f;
}
AddVar( m_flEncodedController, &m_iv_flEncodedController, LATCH_ANIMATION_VAR | EXCLUDE_AUTO_INTERPOLATE );
AddVar( m_flPoseParameter, &m_iv_flPoseParameter, LATCH_ANIMATION_VAR | EXCLUDE_AUTO_INTERPOLATE );
AddVar( &m_flCycle, &m_iv_flCycle, LATCH_ANIMATION_VAR | EXCLUDE_AUTO_INTERPOLATE );
m_lastPhysicsBone = 0;
m_iMostRecentModelBoneCounter = 0xFFFFFFFF;
m_CachedBoneFlags = 0;
m_vecPreRagdollMins = vec3_origin;
m_vecPreRagdollMaxs = vec3_origin;
m_bStoreRagdollInfo = false;
m_pRagdollInfo = NULL;
m_flPlaybackRate = 1.0f;
m_nEventSequence = -1;
m_pIk = NULL;
// Assume false. Derived classes might fill in a receive table entry
// and in that case this would show up as true
m_bClientSideAnimation = false;
m_nPrevNewSequenceParity = -1;
m_nPrevResetEventsParity = -1;
}
//-----------------------------------------------------------------------------
// Purpose: cleanup
//-----------------------------------------------------------------------------
C_BaseAnimating::~C_BaseAnimating()
{
TermRopes();
delete m_pRagdollInfo;
Assert(!m_pRagdoll);
delete m_pIk;
}
bool C_BaseAnimating::UsesFrameBufferTexture( void )
{
studiohdr_t *pmodel = modelinfo->GetStudiomodel( GetModel() );
if ( !pmodel )
return false;
return ( pmodel->flags & STUDIOHDR_FLAGS_USES_FB_TEXTURE ) ? true : false;
}
//-----------------------------------------------------------------------------
// Should this object cast render-to-texture shadows?
//-----------------------------------------------------------------------------
ShadowType_t C_BaseAnimating::ShadowCastType()
{
studiohdr_t *hdr = GetModelPtr();
if ( !hdr )
return SHADOWS_NONE;
if ( IsEffectActive(EF_NODRAW | EF_NOSHADOW) )
return SHADOWS_NONE;
if (hdr->numanim == 0)
return SHADOWS_RENDER_TO_TEXTURE;
// FIXME: Need to check bone controllers and pose parameters
if ((hdr->numanim == 1) && (hdr->pAnimdesc(0)->numframes == 1))
return SHADOWS_RENDER_TO_TEXTURE;
// FIXME: Do something to check to see how many frames the current animation has
return SHADOWS_RENDER_TO_TEXTURE_DYNAMIC;
}
//-----------------------------------------------------------------------------
// Purpose: convert axis rotations to a quaternion
//-----------------------------------------------------------------------------
studiohdr_t *C_BaseAnimating::OnNewModel()
{
if ( !GetModel() )
return NULL;
studiohdr_t *hdr = modelinfo->GetStudiomodel( GetModel() );
if (hdr == NULL)
return NULL;
InvalidateBoneCache();
// Make sure m_CachedBones has space.
if ( m_CachedBones.Count() != hdr->numbones )
{
m_CachedBones.SetSize( hdr->numbones );
}
// Don't reallocate unless a different size.
if ( m_Attachments.Count() != hdr->numattachments)
{
m_Attachments.SetSize( hdr->numattachments );
#ifdef _DEBUG
// This is to make sure we don't use the attachment before its been set up
for ( int i=0; i < m_Attachments.Count(); i++ )
{
float *pOrg = m_Attachments[i].m_vOrigin.Base();
float *pAng = m_Attachments[i].m_angRotation.Base();
pOrg[0] = pOrg[1] = pOrg[2] = VEC_T_NAN;
pAng[0] = pAng[1] = pAng[2] = VEC_T_NAN;
}
#endif
}
Assert( hdr->numposeparameters <= ARRAYSIZE( m_flPoseParameter ) );
m_iv_flPoseParameter.SetMaxCount( hdr->numposeparameters );
int i;
for ( i = 0; i < hdr->numposeparameters ; i++ )
{
mstudioposeparamdesc_t *pPose = hdr->pPoseParameter( i );
m_iv_flPoseParameter.SetLooping( i, pPose->loop != 0.0f );
}
int boneControllerCount = min( hdr->numbonecontrollers, ARRAYSIZE( m_flEncodedController ) );
m_iv_flEncodedController.SetMaxCount( boneControllerCount );
for ( i = 0; i < boneControllerCount ; i++ )
{
bool loop = (hdr->pBonecontroller( i )->type & (STUDIO_XR | STUDIO_YR | STUDIO_ZR)) != 0;
m_iv_flEncodedController.SetLooping( i, loop );
}
InitRopes();
return hdr;
}
studiohdr_t* C_BaseAnimating::GetModelPtr()
{
if ( !GetModel() )
return NULL;
studiohdr_t *hdr = modelinfo->GetStudiomodel( GetModel() );
return hdr;
}
void C_BaseAnimating::InitRopes()
{
TermRopes();
// Parse the keyvalues and see if they want to make ropes on this model.
KeyValues * modelKeyValues = new KeyValues("");
if ( modelKeyValues->LoadFromBuffer( modelinfo->GetModelName( GetModel() ), modelinfo->GetModelKeyValueText( GetModel() ) ) )
{
// Do we have a build point section?
KeyValues *pkvAllCables = modelKeyValues->FindKey("Cables");
if ( pkvAllCables )
{
// Start grabbing the sounds and slotting them in
for ( KeyValues *pSingleCable = pkvAllCables->GetFirstSubKey(); pSingleCable; pSingleCable = pSingleCable->GetNextKey() )
{
C_RopeKeyframe *pRope = C_RopeKeyframe::CreateFromKeyValues( this, pSingleCable );
m_Ropes.AddToTail( pRope );
}
}
}
modelKeyValues->deleteThis();
}
void C_BaseAnimating::TermRopes()
{
FOR_EACH_LL( m_Ropes, i )
m_Ropes[i]->Release();
m_Ropes.Purge();
}
void C_BaseAnimating::GetBoneControllers(float controllers[MAXSTUDIOBONECTRLS])
{
studiohdr_t *hdr = GetModelPtr();
if ( !hdr )
{
return;
}
// interpolate two 0..1 encoded controllers to a single 0..1 controller
int i;
for( i=0; i < MAXSTUDIOBONECTRLS; i++)
{
controllers[ i ] = m_flEncodedController[ i ];
}
}
void C_BaseAnimating::GetPoseParameters( float poseParameter[MAXSTUDIOPOSEPARAM])
{
studiohdr_t *hdr = GetModelPtr();
if ( !hdr )
{
return;
}
// interpolate pose parameters
int i;
for( i=0; i < hdr->numposeparameters; i++)
{
poseParameter[i] = m_flPoseParameter[i];
}
}
float C_BaseAnimating::ClampCycle( float cycle, bool isLooping )
{
if (isLooping)
{
// FIXME: does this work with negative framerate?
cycle = cycle - (int)cycle;
if (cycle < 0)
cycle += 1;
}
else
{
cycle = clamp( cycle, 0.0, 0.999 );
}
return cycle;
}
void C_BaseAnimating::GetCachedBoneMatrix( int boneIndex, matrix3x4_t &out )
{
MatrixCopy( m_CachedBones[ boneIndex ], out );
}
//-----------------------------------------------------------------------------
// Purpose: move position and rotation transforms into global matrices
//-----------------------------------------------------------------------------
void C_BaseAnimating::BuildTransformations( Vector *pos, Quaternion *q, const matrix3x4_t &cameraTransform )
{
VPROF_BUDGET( "C_BaseAnimating::BuildTransformations", VPROF_BUDGETGROUP_OTHER_ANIMATION );
studiohdr_t *hdr = GetModelPtr();
if ( !hdr )
{
return;
}
matrix3x4_t bonematrix;
bool boneSimulated[MAXSTUDIOBONES];
// no bones have been simulated
memset( boneSimulated, 0, sizeof(boneSimulated) );
mstudiobone_t *pbones = hdr->pBone( 0 );
if ( m_pRagdoll )
{
// simulate bones and update flags
m_pRagdoll->RagdollBone( this, pbones, hdr->numbones, boneSimulated, m_CachedBones.Base() );
}
C_BaseAnimating *follow = NULL;
if ( IsFollowingEntity() )
{
follow = FindFollowedEntity();
Assert( follow != this );
if ( follow )
{
follow->SetupBones( NULL, -1, BONE_USED_BY_ANYTHING, gpGlobals->curtime );
}
}
for (int i = 0; i < hdr->numbones; i++)
{
if ( follow )
{
studiohdr_t *fhdr = follow->GetModelPtr();
if ( fhdr )
{
int j;
mstudiobone_t *pfbones = fhdr->pBone( 0 );
for (j = 0; j < fhdr->numbones; j++)
{
if ( stricmp(pbones[i].pszName(), pfbones[j].pszName() ) == 0 )
{
MatrixCopy( follow->m_CachedBones[ j ], m_CachedBones[ i ] );
break;
}
}
if ( j < fhdr->numbones )
continue;
}
}
// animate all non-simulated bones
if ( boneSimulated[i] )
{
continue;
}
else if (CalcProceduralBone( hdr, i, m_CachedBones.Base() ))
{
continue;
}
else
{
QuaternionMatrix( q[i], bonematrix );
bonematrix[0][3] = pos[i][0];
bonematrix[1][3] = pos[i][1];
bonematrix[2][3] = pos[i][2];
if (pbones[i].parent == -1)
{
ConcatTransforms( cameraTransform, bonematrix, m_CachedBones[i] );
// Apply client-side effects to the transformation matrix
// CL_FxTransform( this,pBoneToWorld[i] );
}
else
{
ConcatTransforms( m_CachedBones[pbones[i].parent], bonematrix, m_CachedBones[i] );
}
}
}
}
void C_BaseAnimating::SaveRagdollInfo( int numbones, const matrix3x4_t &cameraTransform, matrix3x4_t *pBoneToWorld )
{
studiohdr_t *hdr = GetModelPtr();
if ( !hdr )
{
return;
}
if ( !m_pRagdollInfo )
{
m_pRagdollInfo = new RagdollInfo_t;
Assert( m_pRagdollInfo );
if ( !m_pRagdollInfo )
{
Msg( "Memory allocation of RagdollInfo_t failed!\n" );
return;
}
memset( m_pRagdollInfo, 0, sizeof( *m_pRagdollInfo ) );
}
mstudiobone_t *pbones = hdr->pBone( 0 );
m_pRagdollInfo->m_bActive = true;
m_pRagdollInfo->m_flSaveTime = gpGlobals->curtime;
m_pRagdollInfo->m_nNumBones = numbones;
for ( int i = 0; i < numbones; i++ )
{
matrix3x4_t inverted;
matrix3x4_t output;
if ( pbones[i].parent == -1 )
{
// Decompose into parent space
MatrixInvert( cameraTransform, inverted );
}
else
{
MatrixInvert( pBoneToWorld[ pbones[ i ].parent ], inverted );
}
ConcatTransforms( inverted, pBoneToWorld[ i ], output );
MatrixAngles( output,
m_pRagdollInfo->m_rgBoneQuaternion[ i ],
m_pRagdollInfo->m_rgBonePos[ i ] );
}
}
bool C_BaseAnimating::RetrieveRagdollInfo( Vector *pos, Quaternion *q )
{
if ( !m_bStoreRagdollInfo || !m_pRagdollInfo || !m_pRagdollInfo->m_bActive )
return false;
for ( int i = 0; i < m_pRagdollInfo->m_nNumBones; i++ )
{
pos[ i ] = m_pRagdollInfo->m_rgBonePos[ i ];
q[ i ] = m_pRagdollInfo->m_rgBoneQuaternion[ i ];
}
return true;
}
//-----------------------------------------------------------------------------
// Should we collide?
//-----------------------------------------------------------------------------
CollideType_t C_BaseAnimating::ShouldCollide( )
{
if ( IsRagdoll() )
return ENTITY_SHOULD_RESPOND;
return BaseClass::ShouldCollide();
}
//-----------------------------------------------------------------------------
// Purpose: if the active sequence changes, keep track of the previous ones and decay them based on their decay rate
//-----------------------------------------------------------------------------
void C_BaseAnimating::MaintainSequenceTransitions( float flCycle, float flPoseParameter[], Vector pos[], Quaternion q[], int boneMask )
{
VPROF( "C_BaseAnimating::MaintainSequenceTransitions" );
studiohdr_t *hdr = GetModelPtr();
if ( !hdr )
{
return;
}
// FIXME?: this should detect that what's been asked to be drawn isn't what was expected
// due to not only sequence change, by frame index, rate, or whatever. When that happens,
// it should insert the previous rules.
if (m_animationQueue.Count() == 0)
{
m_animationQueue.AddToTail();
m_animationQueue[0].nSequence = 0;
m_animationQueue[0].flAnimtime = 0;
m_animationQueue[0].flCycle = 0;
m_animationQueue[0].flPlaybackrate = 0;
}
AnimationLayer_t *currentblend = &m_animationQueue[m_animationQueue.Count()-1];
bool newSeq = m_nNewSequenceParity != m_nPrevNewSequenceParity;
m_nPrevNewSequenceParity = m_nNewSequenceParity;
if (currentblend->flAnimtime &&
(currentblend->nSequence != m_nSequence || newSeq))
{
mstudioseqdesc_t *pseqdesc = hdr->pSeqdesc( m_nSequence );
// sequence changed
if ((pseqdesc->flags & STUDIO_SNAP) || IsEffectActive(EF_NOINTERP))
{
// remove all entries
m_animationQueue.RemoveAll();
}
else
{
currentblend->flFadeOuttime = pseqdesc->fadeouttime;
/*
// clip blends to time remaining
if ( !IsSequenceLooping(currentblend->nSequence) )
{
float length = Studio_Duration( hdr, currentblend->nSequence, flPoseParameter ) / currentblend->flPlaybackrate;
float timeLeft = (1.0 - currentblend->flCycle) * length;
if (timeLeft < currentblend->flFadeOuttime)
currentblend->flFadeOuttime = timeLeft;
}
*/
}
// push previously set sequence
m_animationQueue.AddToTail();
currentblend = &m_animationQueue[m_animationQueue.Count()-1];
}
// keep track of current sequence
currentblend->nSequence = m_nSequence;
currentblend->flAnimtime = gpGlobals->curtime;
currentblend->flCycle = flCycle;
currentblend->flPlaybackrate = m_flPlaybackRate;
// calc blending weights for previous sequences
int i;
AnimationLayer_t *blend;
for (i = 0; i < m_animationQueue.Count() - 1;)
{
float s;
blend = &m_animationQueue[i];
if (blend->flFadeOuttime <= 0.0f)
{
s = 0;
}
else
{
// blend in over 0.2 seconds
s = 1.0 - (gpGlobals->curtime - blend->flAnimtime) / blend->flFadeOuttime;
if (s > 0 && s <= 1.0)
{
// do a nice spline curve
s = 3 * s * s - 2 * s * s * s;
}
else if ( s > 1.0f )
{
// Shouldn't happen, but maybe curtime is behind animtime?
s = 1.0f;
}
}
if (s > 0)
{
blend->flWeight = s;
i++;
}
else
{
m_animationQueue.Remove( i );
}
}
// process previous sequences
for (i = m_animationQueue.Count() - 2; i >= 0; i--)
{
blend = &m_animationQueue[i];
float dt = (gpGlobals->curtime - blend->flAnimtime);
flCycle = blend->flCycle + dt * blend->flPlaybackrate * GetSequenceCycleRate( blend->nSequence );
flCycle = ClampCycle( flCycle, IsSequenceLooping( blend->nSequence ) );
AccumulatePose( hdr, m_pIk, pos, q, blend->nSequence, flCycle, flPoseParameter, boneMask, blend->flWeight );
}
}
//-----------------------------------------------------------------------------
// Purpose: Do the default sequence blending rules as done in HL1
//-----------------------------------------------------------------------------
void C_BaseAnimating::StandardBlendingRules( Vector pos[], Quaternion q[], float currentTime, int boneMask )
{
VPROF( "C_BaseAnimating::StandardBlendingRules" );
float poseparam[MAXSTUDIOPOSEPARAM];
studiohdr_t *hdr = GetModelPtr();
if ( !hdr )
{
return;
}
if (m_nSequence >= hdr->numseq)
{
m_nSequence = 0;
}
GetPoseParameters( poseparam);
// build root animation
float fCycle = m_flCycle;
InitPose( hdr, pos, q );
AccumulatePose( hdr, m_pIk, pos, q, m_nSequence, fCycle, poseparam, boneMask );
// debugoverlay->AddTextOverlay( GetAbsOrigin() + Vector( 0, 0, 64 ), 0, 0, "%30s %6.2f : %6.2f", hdr->pSeqdesc( m_nSequence )->pszLabel( ), fCycle, 1.0 );
MaintainSequenceTransitions( fCycle, poseparam, pos, q, boneMask );
CIKContext auto_ik;
auto_ik.Init( hdr, GetRenderAngles(), GetRenderOrigin(), gpGlobals->curtime );
CalcAutoplaySequences( hdr, &auto_ik, pos, q, poseparam, boneMask, currentTime );
float controllers[MAXSTUDIOBONECTRLS];
GetBoneControllers(controllers);
CalcBoneAdj( hdr, pos, q, controllers, boneMask );
}
//-----------------------------------------------------------------------------
// Purpose: Put a value into an attachment point by index
// Input : number - which point
// Output : float * - the attachment point
//-----------------------------------------------------------------------------
bool C_BaseAnimating::PutAttachment( int number, const Vector &origin, const QAngle &angles )
{
if ( number < 1 || number > m_Attachments.Count() )
{
return false;
}
m_Attachments[number-1].m_vOrigin = origin;
m_Attachments[number-1].m_angRotation = angles;
return true;
}
void C_BaseAnimating::SetupBones_AttachmentHelper()
{
studiohdr_t *hdr = GetModelPtr();
if ( !hdr )
{
return;
}
// calculate attachment points
mstudioattachment_t *pattachment = hdr->pAttachment( 0 );
matrix3x4_t world;
for (int i = 0; i < hdr->numattachments; i++)
{
ConcatTransforms( m_CachedBones[ pattachment[i].bone ], pattachment[i].local, world );
// FIXME: this shouldn't be here, it should client side on-demand only and hooked into the bone cache!!
QAngle angles;
Vector origin;
MatrixAngles( world, angles, origin );
FormatViewModelAttachment( i, origin, angles );
PutAttachment( i + 1, origin, angles );
}
}
bool C_BaseAnimating::CalcAttachments()
{
VPROF( "C_BaseAnimating::CalcAttachments" );
// Make sure m_CachedBones is valid.
if ( !SetupBones( NULL, -1, BONE_USED_BY_ATTACHMENT, gpGlobals->curtime ) )
{
return false;
}
return true;
}
//-----------------------------------------------------------------------------
// Purpose: Get attachment point by index
// Input : number - which point
// Output : float * - the attachment point
//-----------------------------------------------------------------------------
bool C_BaseAnimating::GetAttachment( int number, Vector &origin, QAngle &angles )
{
// Note: this could be more efficient, but we want the matrix3x4_t version of GetAttachment to be the origin of
// attachment generation, so a derived class that wants to fudge attachments only
// has to reimplement that version. This also makes it work like the server in that regard.
matrix3x4_t attachmentToWorld;
if ( !GetAttachment( number, attachmentToWorld) )
return false;
MatrixAngles( attachmentToWorld, angles );
MatrixPosition( attachmentToWorld, origin );
return true;
}
// UNDONE: Should be able to do this directly!!!
// Attachments begin as matrices!!
bool C_BaseAnimating::GetAttachment( int number, matrix3x4_t& matrix )
{
if ( number < 1 || number > m_Attachments.Count() )
{
return false;
}
if ( !CalcAttachments() )
return false;
Vector &origin = m_Attachments[number-1].m_vOrigin;
QAngle &angles = m_Attachments[number-1].m_angRotation;
AngleMatrix( angles, origin, matrix );
return true;
}
//-----------------------------------------------------------------------------
// Returns the attachment in local space
//-----------------------------------------------------------------------------
bool C_BaseAnimating::GetAttachmentLocal( int iAttachment, matrix3x4_t &attachmentToLocal )
{
matrix3x4_t attachmentToWorld;
if (!GetAttachment(iAttachment, attachmentToWorld))
return false;
matrix3x4_t worldToEntity;
MatrixInvert( EntityToWorldTransform(), worldToEntity );
ConcatTransforms( worldToEntity, attachmentToWorld, attachmentToLocal );
return true;
}
bool C_BaseAnimating::GetAttachmentLocal( int iAttachment, Vector &origin, QAngle &angles )
{
matrix3x4_t attachmentToEntity;
if (GetAttachmentLocal( iAttachment, attachmentToEntity ))
{
origin.Init( attachmentToEntity[0][3], attachmentToEntity[1][3], attachmentToEntity[2][3] );
MatrixAngles( attachmentToEntity, angles );
return true;
}
return false;
}
bool C_BaseAnimating::IsViewModel() const
{
return false;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
mstudiohitboxset_t *C_BaseAnimating::GetTransformedHitboxSet( int nBoneMask )
{
studiohdr_t *hdr = GetModelPtr();
if ( !hdr )
{
return NULL;
}
mstudiohitboxset_t *set = hdr->pHitboxSet( m_nHitboxSet );
if ( set && set->numhitboxes )
{
studiocache_t *pcache = Studio_GetBoneCache( hdr, m_nSequence, m_flAnimTime, GetAbsAngles(), GetAbsOrigin(), nBoneMask );
if ( !pcache )
{
matrix3x4_t bonetoworld[MAXSTUDIOBONES];
SetupBones( bonetoworld, MAXSTUDIOBONES, BONE_USED_BY_HITBOX, gpGlobals->curtime );
pcache = Studio_SetBoneCache( hdr, m_nSequence, m_flAnimTime, GetAbsAngles(), GetAbsOrigin(), nBoneMask, bonetoworld );
}
matrix3x4_t *hitboxbones[MAXSTUDIOBONES];
Studio_LinkHitboxCache( hitboxbones, pcache, hdr, set );
}
return set;
}
void C_BaseAnimating::CalculateIKLocks( float currentTime )
{
if (m_pIk)
{
// In TF, we might be attaching a player's view to a walking model that's using IK. If we are, it can
// get in here during the view setup code, and it's not normally supposed to be able to access the spatial
// partition that early in the rendering loop. So we allow access right here for that special case.
SpatialPartitionListMask_t curSuppressed = partition->GetSuppressedLists();
partition->SuppressLists( PARTITION_ALL_CLIENT_EDICTS, false );
// FIXME: trace based on gravity or trace based on angles?
Vector up;
AngleVectors( GetRenderAngles(), NULL, NULL, &up );
// FIXME: check number of slots?
for (int i = 0; i < m_pIk->m_target.Count(); i++)
{
trace_t tr;
iktarget_t *pTarget = &m_pIk->m_target[i];
if (pTarget->est.time != currentTime)
continue;
Vector p1, p2;
VectorMA( pTarget->est.pos, pTarget->est.height, up, p1 );
VectorMA( pTarget->est.pos, -pTarget->est.height, up, p2 );
float r = pTarget->est.radius;
UTIL_TraceHull( p1, p2, Vector( -r, -r, 0 ), Vector( r, r, 1 ),
MASK_SOLID, this, COLLISION_GROUP_NONE, &tr );
pTarget->est.pos = tr.endpos;
/*
debugoverlay->AddTextOverlay( p1, 0, 0, "%d", i );
debugoverlay->AddBoxOverlay( pTarget->est.pos, Vector( -2, -2, -2 ), Vector( 2, 2, 2), QAngle( 0, 0, 0 ), 255, 0, 0, 0, 0 );
debugoverlay->AddBoxOverlay( pTarget->latched.pos, Vector( -2, -2, 2 ), Vector( 2, 2, 6), QAngle( 0, 0, 0 ), 0, 255, 0, 0, 0 );
*/
}
partition->SuppressLists( curSuppressed, true );
}
}
mstudioposeparamdesc_t *C_BaseAnimating::GetPoseParameterPtr( const char *pName )
{
studiohdr_t *pstudiohdr = GetModelPtr( );
if ( !pstudiohdr )
return NULL;
for (int i = 0; i < pstudiohdr->numposeparameters; i++)
{
mstudioposeparamdesc_t *pPose = pstudiohdr->pPoseParameter( i );
if ( pPose && ( stricmp( pstudiohdr->pPoseParameter( i )->pszName(), pName ) == 0 ) )
{
return pPose;
}
}
return NULL;
}
//-----------------------------------------------------------------------------
// Purpose: Do HL1 style lipsynch
//-----------------------------------------------------------------------------
void C_BaseAnimating::ControlMouth( void )
{
studiohdr_t *pstudiohdr = GetModelPtr( );
if ( !pstudiohdr )
return;
mstudioposeparamdesc_t *pPose = GetPoseParameterPtr( LIPSYNC_POSEPARAM_NAME );
if ( pPose )
{
float value = GetMouth()->mouthopen / 64.0;
float raw = value;
if ( value > 1.0 )
value = 1.0;
value = (1.0 - value) * pPose->start + value * pPose->end;
//Adrian - Set the pose parameter value.
//It has to be called "mouth".
SetPoseParameter( LIPSYNC_POSEPARAM_NAME, value );
// Reset interpolation here since the client is controlling this rather than the server...
int index = LookupPoseParameter( LIPSYNC_POSEPARAM_NAME );
if ( index >= 0 )
{
m_iv_flPoseParameter.SetHistoryValuesForItem( index, raw );
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Do the default sequence blending rules as done in HL1
//-----------------------------------------------------------------------------
bool C_BaseAnimating::SetupBones( matrix3x4_t *pBoneToWorldOut, int nMaxBones, int boneMask, float currentTime )
{
VPROF_BUDGET( "C_BaseAnimating::SetupBones", VPROF_BUDGETGROUP_OTHER_ANIMATION );
Assert( IsBoneAccessAllowed() );
boneMask = BONE_USED_BY_ANYTHING; // HACK HACK - this is a temp fix until we have accessors for bones to find out where problems are.
studiohdr_t *hdr = GetModelPtr();
if ( !hdr )
{
return false;
}
if( m_iMostRecentModelBoneCounter != g_iModelBoneCounter )
{
// Clear out which bones we've touched this frame if this is
// the first time we've seen this object this frame.
m_CachedBoneFlags = 0;
}
// Have we cached off all bones meeting the flag set?
if( ( m_CachedBoneFlags & boneMask ) != boneMask )
{
MEASURE_TIMED_STAT( CS_BONE_SETUP_TIME );
// Setup our transform based on render angles and origin.
matrix3x4_t parentTransform;
AngleMatrix( GetRenderAngles(), GetRenderOrigin(), parentTransform );
if (hdr->flags & STUDIOHDR_FLAGS_STATIC_PROP)
{
MatrixCopy( parentTransform, m_CachedBones[0] );
}
else
{
if (!m_pIk)
m_pIk = new CIKContext;
Vector pos[MAXSTUDIOBONES];
Quaternion q[MAXSTUDIOBONES];
m_pIk->Init( hdr, GetRenderAngles(), GetRenderOrigin(), currentTime );
int bonesMaskNeedRecalc = boneMask & ~m_CachedBoneFlags;
StandardBlendingRules( pos, q, currentTime, bonesMaskNeedRecalc );
CalculateIKLocks( currentTime );
m_pIk->SolveDependencies( pos, q );
BuildTransformations( pos, q, parentTransform );
}
if( !( m_CachedBoneFlags & BONE_USED_BY_ATTACHMENT ) && ( boneMask & BONE_USED_BY_ATTACHMENT ) )
{
SetupBones_AttachmentHelper();
}
}
ControlMouth();
// Do they want to get at the bone transforms? If it's just making sure an aiment has
// its bones setup, it doesn't need the transforms yet.
if ( pBoneToWorldOut )
{
if ( nMaxBones >= m_CachedBones.Count() )
{
memcpy( pBoneToWorldOut, m_CachedBones.Base(), sizeof( matrix3x4_t ) * m_CachedBones.Count() );
}
else
{
Warning( "SetupBones: invalid bone array size (%d - needs %d)\n", nMaxBones, m_CachedBones.Count() );
return false;
}
}
// Make sure that we know that we've already calculated some bone stuff this time around.
m_iMostRecentModelBoneCounter = g_iModelBoneCounter;
// OR in the stuff that we just calculated so that we don't calculate it again for the same model.
m_CachedBoneFlags |= boneMask;
return true;
}
C_BaseAnimating* C_BaseAnimating::FindFollowedEntity()
{
C_BaseEntity *follow = GetFollowedEntity();
if ( !follow )
return NULL;
if ( !follow->GetModel() )
{
Warning( "mod_studio: MOVETYPE_FOLLOW with no model.\n" );
return NULL;
}
if ( modelinfo->GetModelType( follow->GetModel() ) != mod_studio )
{
Warning( "Attached %s (mod_studio) to %s (%d)\n",
modelinfo->GetModelName( GetModel() ),
modelinfo->GetModelName( follow->GetModel() ),
modelinfo->GetModelType( follow->GetModel() ) );
return NULL;
}
return dynamic_cast< C_BaseAnimating* >( follow );
}
void C_BaseAnimating::InvalidateBoneCache()
{
m_iMostRecentModelBoneCounter = g_iModelBoneCounter - 1;
}
// Causes an assert to happen if bones or attachments are used while this is false.
struct BoneAccess
{
BoneAccess()
{
bAllowBoneAccessForNormalModels = false;
bAllowBoneAccessForViewModels = false;
}
bool bAllowBoneAccessForNormalModels;
bool bAllowBoneAccessForViewModels;
};
static CUtlVector< BoneAccess > g_BoneAccessStack;
static BoneAccess g_BoneAcessBase;
bool C_BaseAnimating::IsBoneAccessAllowed() const
{
if ( IsViewModel() )
return g_BoneAcessBase.bAllowBoneAccessForViewModels;
else
return g_BoneAcessBase.bAllowBoneAccessForNormalModels;
}
// (static function)
void C_BaseAnimating::AllowBoneAccess( bool bAllowForNormalModels, bool bAllowForViewModels )
{
Assert( g_BoneAccessStack.Count() == 0 );
// Make sure it's empty...
g_BoneAccessStack.RemoveAll();
g_BoneAcessBase.bAllowBoneAccessForNormalModels = bAllowForNormalModels;
g_BoneAcessBase.bAllowBoneAccessForViewModels = bAllowForViewModels;
}
void C_BaseAnimating::PushAllowBoneAccess( bool bAllowForNormalModels, bool bAllowForViewModels )
{
BoneAccess save = g_BoneAcessBase;
g_BoneAccessStack.AddToTail( save );
g_BoneAcessBase.bAllowBoneAccessForNormalModels = bAllowForNormalModels;
g_BoneAcessBase.bAllowBoneAccessForViewModels = bAllowForViewModels;
}
void C_BaseAnimating::PopBoneAccess( void )
{
int lastIndex = g_BoneAccessStack.Count() - 1;
if ( lastIndex < 0 )
{
Assert( !"C_BaseAnimating::PopBoneAccess: Stack is empty!!!" );
return;
}
g_BoneAcessBase = g_BoneAccessStack[lastIndex ];
g_BoneAccessStack.Remove( lastIndex );
}
// (static function)
void C_BaseAnimating::InvalidateBoneCaches()
{
g_iModelBoneCounter++;
}
//-----------------------------------------------------------------------------
// Purpose: Draws the object
// Input : flags -
//-----------------------------------------------------------------------------
int C_BaseAnimating::DrawModel( int flags )
{
VPROF_BUDGET( "C_BaseAnimating::DrawModel", VPROF_BUDGETGROUP_MODEL_RENDERING );
MEASURE_TIMED_STAT( CS_DRAW_STUDIO_MODEL_TIME );
if ( !m_bReadyToDraw )
return 0;
// Testing out different vehicle stuff.
if ( GetClientVehicle() && !r_drawvehicles.GetInt() )
return 0;
int drawn = 0;
if ( r_drawmrmmodels.GetInt() )
{
render->BeginDrawMRM();
engineCache->EnterCriticalSection( );
if ( !IsFollowingEntity() )
{
drawn = InternalDrawModel( flags );
}
else
{
// this doesn't draw unless master entity is visible and it's a studio model!!!
C_BaseAnimating *follow = FindFollowedEntity();
if ( follow )
{
// recompute master entity bone structure
int baseDrawn = follow->DrawModel( STUDIO_FRUSTUMCULL );
// draw entity
// FIXME: Currently only draws if aiment is drawn.
// BUGBUG: Fixup bbox and do a separate cull for follow object
if ( baseDrawn )
{
drawn = InternalDrawModel( STUDIO_RENDER );
}
}
}
engineCache->ExitCriticalSection( );
render->EndDrawMRM();
}
// If we're visualizing our bboxes, draw them
if ( m_bVisualizingBBox || m_bVisualizingAbsBox )
{
DrawBBoxVisualizations();
}
return drawn;
}
C_BaseAnimating::studiovisible_t C_BaseAnimating::TestVisibility( void )
{
// Let the ragdolls cull themselves since the engine's sequence box will not
// properly account for physics simulation
if ( IsRagdoll() )
{
Vector tmpmins, tmpmaxs;
Vector origin = m_pRagdoll->GetRagdollOrigin();
m_pRagdoll->GetRagdollBounds( tmpmins, tmpmaxs );
tmpmins += origin;
tmpmaxs += origin;
if ( engine->CullBox( tmpmins, tmpmaxs ) )
{
return VIS_NOT_VISIBLE;
}
return VIS_IS_VISIBLE;
}
return VIS_USE_ENGINE;
}
ConVar vcollide_wireframe( "vcollide_wireframe", "0" );
ConVar vcollide_axes( "vcollide_axes", "0" );
//-----------------------------------------------------------------------------
// Purpose: Draws the object
// Input : flags -
//-----------------------------------------------------------------------------
int C_BaseAnimating::InternalDrawModel( int flags )
{
VPROF( "C_BaseAnimating::InternalDrawModel" );
if ( !GetModel() )
return 0;
// This should never happen, but if the server class hierarchy has bmodel entities derived from CBaseAnimating or does a
// SetModel with the wrong type of model, this could occur.
if ( modelinfo->GetModelType( GetModel() ) != mod_studio )
{
return BaseClass::DrawModel( flags );
}
// Make sure hdr is valid for drawing
if ( !GetModelPtr() )
return 0;
// UNDONE: With a bit of work on the model->world transform, we can probably
// move the frustum culling into the client DLL entirely. Then TestVisibility()
// can just return true/false and only be called when frustumcull is set.
if ( flags & STUDIO_FRUSTUMCULL )
{
switch ( TestVisibility() )
{
// not visible, don't draw
case VIS_NOT_VISIBLE:
return 0;
// definitely visible, disable engine check
case VIS_IS_VISIBLE:
flags &= ~STUDIO_FRUSTUMCULL;
break;
default:
case VIS_USE_ENGINE:
break;
}
}
int drawn = modelrender->DrawModel(
flags,
this,
GetModelInstance(),
index,
GetModel(),
GetRenderOrigin(),
GetRenderAngles(),
m_nSequence, // only used for clipping. Remove
m_nSkin,
m_nBody,
m_nHitboxSet );
if ( vcollide_wireframe.GetBool() )
{
if ( IsRagdoll() )
{
m_pRagdoll->DrawWireframe();
}
else
{
vcollide_t *pCollide = modelinfo->GetVCollide( GetModelIndex() );
if ( pCollide && pCollide->solidCount == 1 )
{
static color32 debugColor = {0,255,255,0};
matrix3x4_t matrix;
AngleMatrix( GetAbsAngles(), GetAbsOrigin(), matrix );
engine->DebugDrawPhysCollide( pCollide->solids[0], NULL, matrix, debugColor );
}
}
}
return drawn;
}
//-----------------------------------------------------------------------------
// Purpose: Called by networking code when an entity is new to the PVS or comes down with the EF_NOINTERP flag set.
// The position history data is flushed out right after this call, so we need to store off the current data
// in the latched fields so we try to interpolate
// Input : *ent -
// full_reset -
//-----------------------------------------------------------------------------
void C_BaseAnimating::DoAnimationEvents( void )
{
// don't fire events when paused
if ( gpGlobals->frametime == 0.0f )
return;
studiohdr_t *hdr = GetModelPtr();
if ( !hdr )
{
return;
}
bool watch = false; // Q_strstr( hdr->name, "rifle" ) ? true : false;
Assert( hdr );
float poseparam[MAXSTUDIOPOSEPARAM];
GetPoseParameters( poseparam );
// build root animation
float flEventCycle = m_flCycle;
// add in muzzleflash effect
if ( IsEffectActive(EF_MUZZLEFLASH) && m_Attachments.Count() > 0 )
{
Vector vAttachment;
QAngle dummyAngles;
GetAttachment( 1, vAttachment, dummyAngles );
dlight_t *el = effects->CL_AllocDlight( LIGHT_INDEX_MUZZLEFLASH + index );
el->origin = vAttachment;
el->radius = 100;
el->decay = el->radius / 0.05f;
el->die = gpGlobals->curtime + 0.05f;
el->color.r = 255;
el->color.g = 192;
el->color.b = 64;
el->color.exponent = 5;
ActivateEffect( EF_MUZZLEFLASH, false );
}
// If we're invisible, don't process animation events.
if ( !ShouldDraw() && !IsViewModel() )
return;
mstudioseqdesc_t *pseqdesc = hdr->pSeqdesc( m_nSequence );
mstudioevent_t *pevent = pseqdesc->pEvent( 0 );
if (pseqdesc->numevents == 0)
return;
if ( watch )
{
Msg( "%i cycle %f\n", gpGlobals->framecount, m_flCycle );
}
bool resetEvents = m_nResetEventsParity != m_nPrevResetEventsParity;
m_nPrevResetEventsParity = m_nResetEventsParity;
if (m_nEventSequence != m_nSequence || resetEvents )
{
if ( watch )
{
Msg( "new seq %i old seq %i reset %s m_flCycle %f (time %.3f)\n",
m_nSequence, m_nEventSequence,
resetEvents ? "true" : "false",
m_flCycle,
gpGlobals->curtime);
}
m_nEventSequence = m_nSequence;
flEventCycle = 0.0f;
m_flPrevEventCycle = -0.01; // back up to get 0'th frame animations
}
// stalled?
if (flEventCycle == m_flPrevEventCycle)
return;
if ( watch )
{
Msg( "%i (seq %d cycle %.3f ) evcycle %.3f prevevcycle %.3f (time %.3f)\n", gpGlobals->tickcount,
m_nSequence, m_flCycle, flEventCycle, m_flPrevEventCycle, gpGlobals->curtime );
}
// check for looping
BOOL bLooped = false;
if (flEventCycle <= m_flPrevEventCycle)
{
if (m_flPrevEventCycle - flEventCycle > 0.5)
{
bLooped = true;
}
else
{
// things have backed up, which is bad since it'll probably result in a hitch in the animation playback
// but, don't play events again for the same time slice
return;
}
}
for (int i = 0; i < pseqdesc->numevents; i++)
{
// ignore all non-client-side events
if ( pevent[i].event < 5000 )
continue;
// looped
if (bLooped)
{
if ( (pevent[i].cycle > m_flPrevEventCycle || pevent[i].cycle <= flEventCycle) )
{
if ( watch )
Msg( "%i FE %i Looped cycle %f, prev %f ev %f (time %.3f)\n",
gpGlobals->tickcount,
pevent[i].event,
pevent[i].cycle,
m_flPrevEventCycle,
flEventCycle,
gpGlobals->curtime );
FireEvent( GetAbsOrigin(), GetAbsAngles(), pevent[ i ].event, pevent[ i ].options );
}
}
else
{
if ( (pevent[i].cycle > m_flPrevEventCycle && pevent[i].cycle <= flEventCycle) )
{
if ( watch )
Msg( "%i FE %i Normal cycle %f, prev %f ev %f (time %.3f)\n",
gpGlobals->tickcount,
pevent[i].event,
pevent[i].cycle,
m_flPrevEventCycle,
flEventCycle,
gpGlobals->curtime );
FireEvent( GetAbsOrigin(), GetAbsAngles(), pevent[ i ].event, pevent[ i ].options );
}
}
}
m_flPrevEventCycle = flEventCycle;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *origin -
// *angles -
// event -
// *options -
// numAttachments -
// attachments[] -
//-----------------------------------------------------------------------------
void C_BaseAnimating::FireEvent( const Vector& origin, const QAngle& angles, int event, const char *options )
{
int entId = render->GetViewEntity();
Vector vecForward, attachOrigin;
QAngle attachAngles;
switch( event )
{
// Spark
case CL_EVENT_SPARK0:
GetAttachment( 1, attachOrigin, attachAngles );
AngleVectors( attachAngles, &vecForward );
g_pEffects->Sparks( attachOrigin, atoi( options ), 1, &vecForward );
break;
// Sound
case CL_EVENT_SOUND: // Client side sound
{
CLocalPlayerFilter filter;
if ( m_Attachments.Count() > 0)
{
GetAttachment( 1, attachOrigin, attachAngles );
EmitSound( filter, entId, options, &attachOrigin );
}
else
{
EmitSound( filter, entId, options );
}
}
break;
// Eject brass
case CL_EVENT_EJECTBRASS1:
if ( m_Attachments.Count() > 0 )
{
Vector attachOrigin;
QAngle attachAngles;
GetAttachment( 2, attachOrigin, attachAngles );
tempents->EjectBrass( attachOrigin, attachAngles, GetAbsAngles(), atoi( options ) );
}
break;
// Generic dispatch effect hook
case CL_EVENT_DISPATCHEFFECT0:
case CL_EVENT_DISPATCHEFFECT1:
case CL_EVENT_DISPATCHEFFECT2:
case CL_EVENT_DISPATCHEFFECT3:
case CL_EVENT_DISPATCHEFFECT4:
case CL_EVENT_DISPATCHEFFECT5:
case CL_EVENT_DISPATCHEFFECT6:
case CL_EVENT_DISPATCHEFFECT7:
case CL_EVENT_DISPATCHEFFECT8:
case CL_EVENT_DISPATCHEFFECT9:
{
int iAttachment = -1;
// First person muzzle flashes
switch (event)
{
case CL_EVENT_DISPATCHEFFECT0:
iAttachment = 0;
break;
case CL_EVENT_DISPATCHEFFECT1:
iAttachment = 1;
break;
case CL_EVENT_DISPATCHEFFECT2:
iAttachment = 2;
break;
case CL_EVENT_DISPATCHEFFECT3:
iAttachment = 3;
break;
case CL_EVENT_DISPATCHEFFECT4:
iAttachment = 4;
break;
case CL_EVENT_DISPATCHEFFECT5:
iAttachment = 5;
break;
case CL_EVENT_DISPATCHEFFECT6:
iAttachment = 6;
break;
case CL_EVENT_DISPATCHEFFECT7:
iAttachment = 7;
break;
case CL_EVENT_DISPATCHEFFECT8:
iAttachment = 8;
break;
case CL_EVENT_DISPATCHEFFECT9:
iAttachment = 9;
break;
}
if ( iAttachment != -1 && m_Attachments.Count() > iAttachment )
{
GetAttachment( iAttachment+1, attachOrigin, attachAngles );
// Fill out the generic data
CEffectData data;
data.m_vOrigin = attachOrigin;
data.m_vAngles = attachAngles;
AngleVectors( attachAngles, &data.m_vNormal );
data.m_nEntIndex = entindex();
DispatchEffect( options, data );
}
}
break;
// Old muzzleflashes
case CL_EVENT_MUZZLEFLASH0:
case CL_EVENT_MUZZLEFLASH1:
case CL_EVENT_MUZZLEFLASH2:
case CL_EVENT_MUZZLEFLASH3:
case CL_EVENT_NPC_MUZZLEFLASH0:
case CL_EVENT_NPC_MUZZLEFLASH1:
case CL_EVENT_NPC_MUZZLEFLASH2:
case CL_EVENT_NPC_MUZZLEFLASH3:
{
int iAttachment = -1;
bool bFirstPerson = true;
// First person muzzle flashes
switch (event)
{
case CL_EVENT_MUZZLEFLASH0:
iAttachment = 0;
break;
case CL_EVENT_MUZZLEFLASH1:
iAttachment = 1;
break;
case CL_EVENT_MUZZLEFLASH2:
iAttachment = 2;
break;
case CL_EVENT_MUZZLEFLASH3:
iAttachment = 3;
break;
// Third person muzzle flashes
case CL_EVENT_NPC_MUZZLEFLASH0:
iAttachment = 0;
bFirstPerson = false;
break;
case CL_EVENT_NPC_MUZZLEFLASH1:
iAttachment = 1;
bFirstPerson = false;
break;
case CL_EVENT_NPC_MUZZLEFLASH2:
iAttachment = 2;
bFirstPerson = false;
break;
case CL_EVENT_NPC_MUZZLEFLASH3:
iAttachment = 3;
bFirstPerson = false;
break;
}
if ( iAttachment != -1 && m_Attachments.Count() > iAttachment )
{
GetAttachment( iAttachment+1, attachOrigin, attachAngles );
tempents->MuzzleFlash( attachOrigin, attachAngles, atoi( options ), entId, bFirstPerson );
}
}
break;
default:
break;
}
}
bool C_BaseAnimating::IsSelfAnimating()
{
if ( m_bClientSideAnimation )
return true;
// Yes, we use animtime.
int iMoveType = GetMoveType();
if ( iMoveType != MOVETYPE_STEP &&
iMoveType != MOVETYPE_NONE &&
iMoveType != MOVETYPE_WALK &&
iMoveType != MOVETYPE_FLY &&
iMoveType != MOVETYPE_FLYGRAVITY )
{
return true;
}
return false;
}
//-----------------------------------------------------------------------------
// Purpose: Called by networking code when an entity is new to the PVS or comes down with the EF_NOINTERP flag set.
// The position history data is flushed out right after this call, so we need to store off the current data
// in the latched fields so we try to interpolate
// Input : *ent -
// full_reset -
//-----------------------------------------------------------------------------
void C_BaseAnimating::ResetLatched( void )
{
// Reset the IK
if ( m_pIk )
{
delete m_pIk;
m_pIk = NULL;
}
BaseClass::ResetLatched();
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool C_BaseAnimating::Interpolate( float currentTime )
{
// ragdolls don't need interpolation
if ( m_pRagdoll )
return true;
if ( !BaseClass::Interpolate( currentTime ) )
return false;
if ( GetPredictable() || IsClientCreated() )
return true;
studiohdr_t *hdr = GetModelPtr();
if ( !hdr )
{
return 0.0f;
}
m_iv_flPoseParameter.Interpolate( this, currentTime );
m_iv_flEncodedController.Interpolate( this, currentTime );
if ( !m_bClientSideAnimation )
{
m_iv_flCycle.SetLooping( IsSequenceLooping( m_nSequence ) );
m_iv_flCycle.Interpolate( this, currentTime );
}
return true;
}
//-----------------------------------------------------------------------------
// returns true if we're currently being ragdolled
//-----------------------------------------------------------------------------
bool C_BaseAnimating::IsRagdoll() const
{
return m_pRagdoll && (m_nRenderFX == kRenderFxRagdoll);
}
//-----------------------------------------------------------------------------
// implements these so ragdolls can handle frustum culling & leaf visibility
//-----------------------------------------------------------------------------
void C_BaseAnimating::GetRenderBounds( Vector& theMins, Vector& theMaxs )
{
if ( IsRagdoll() )
{
m_pRagdoll->GetRagdollBounds( theMins, theMaxs );
}
else
{
// NOTE: Don't use the base class GetRenderBounds, we need to
// take the sequence into account, and we know we're a studio model
// at this stage.
modelinfo->GetModelRenderBounds( GetModel(), m_nSequence, theMins, theMaxs );
}
}
//-----------------------------------------------------------------------------
// Purpose: My physics object has been updated, react or extract data
//-----------------------------------------------------------------------------
void C_BaseAnimating::VPhysicsUpdate( IPhysicsObject *pPhysics )
{
// FIXME: Should make sure the physics objects being passed in
// is the ragdoll physics object, but I think it's pretty safe not to check
if (IsRagdoll())
{
m_pRagdoll->VPhysicsUpdate( pPhysics );
SetAbsOrigin( m_pRagdoll->GetRagdollOrigin() );
SetAbsAngles( vec3_angle );
Vector mins, maxs;
m_pRagdoll->GetRagdollBounds( mins, maxs );
SetCollisionBounds( mins, maxs );
Relink();
return;
}
BaseClass::VPhysicsUpdate( pPhysics );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : updateType -
//-----------------------------------------------------------------------------
void C_BaseAnimating::PreDataUpdate( DataUpdateType_t updateType )
{
BaseClass::PreDataUpdate( updateType );
if ( m_bClientSideAnimation )
{
m_flOldCycle = m_flCycle;
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : updateType -
//-----------------------------------------------------------------------------
void C_BaseAnimating::PostDataUpdate( DataUpdateType_t updateType )
{
BaseClass::PostDataUpdate( updateType );
if ( m_bClientSideAnimation )
{
m_flCycle = m_flOldCycle;
}
// reset prev cycle if new sequence
if (m_nNewSequenceParity != m_nPrevNewSequenceParity)
{
m_iv_flCycle.Reset();
}
/*
studiohdr_t *hdr = GetModelPtr();
if (hdr && stricmp( hdr->name, "player.mdl") != 0)
{
Msg("PostDataUpdate : %d %.3f : %.3f %.3f : %d:%d %s\n",
m_nSequence, m_flAnimTime,
m_flCycle, m_flPrevCycle,
m_nNewSequenceParity, m_nPrevNewSequenceParity, hdr->name );
}
*/
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : bnewentity -
//-----------------------------------------------------------------------------
void C_BaseAnimating::OnPreDataChanged( DataUpdateType_t updateType )
{
BaseClass::OnPreDataChanged( updateType );
m_bLastClientSideFrameReset = m_bClientSideFrameReset;
}
void C_BaseAnimating::BecomeRagdollOnClient()
{
studiohdr_t *hdr = GetModelPtr();
if ( !hdr )
{
return;
}
if ( m_pRagdoll || m_builtRagdoll )
return;
m_builtRagdoll = true;
// Store off our old mins & maxs
m_vecPreRagdollMins = WorldAlignMins();
m_vecPreRagdollMaxs = WorldAlignMaxs();
matrix3x4_t preBones[MAXSTUDIOBONES];
// Force MOVETYPE_STEP interpolation
MoveType_t savedMovetype = GetMoveType();
SetMoveType( MOVETYPE_STEP );
// HACKHACK: force time to last interpolation position
m_flPlaybackRate = 1;
float prevanimtime = gpGlobals->curtime - 0.1f;
Interpolate( prevanimtime );
// Setup previous bone state to extrapolate physics velocity
SetupBones( preBones, MAXSTUDIOBONES, BONE_USED_BY_ANYTHING, prevanimtime );
// blow the cached prev bones
InvalidateBoneCache();
// reset absorigin/absangles
Interpolate( gpGlobals->curtime );
// Now do the current bone setup
SetupBones( NULL, -1, BONE_USED_BY_ANYTHING, gpGlobals->curtime );
m_pRagdoll = CreateRagdoll( this, hdr, m_vecForce, m_nForceBone, preBones, m_CachedBones.Base(), gpGlobals->curtime - prevanimtime );
// Cache off ragdoll bone positions/quaternions
if ( m_bStoreRagdollInfo && m_pRagdoll )
{
matrix3x4_t parentTransform;
AngleMatrix( GetAbsAngles(), GetAbsOrigin(), parentTransform );
// FIXME/CHECK: This might be too expensive to do every frame???
SaveRagdollInfo( hdr->numbones, parentTransform, m_CachedBones.Base() );
}
SetMoveType( savedMovetype );
// Now set the dieragdoll sequence to get transforms for all
// non-simulated bones
m_nRestoreSequence = m_nSequence;
m_nSequence = LookupSequence( "ACT_DIERAGDOLL" );
m_nPrevSequence = m_nSequence;
m_flPlaybackRate = 0;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : bnewentity -
//-----------------------------------------------------------------------------
void C_BaseAnimating::OnDataChanged( DataUpdateType_t updateType )
{
// don't let server change sequences after becoming a ragdoll
if ( m_pRagdoll && m_nSequence != m_nPrevSequence )
{
m_nSequence = m_nPrevSequence;
m_flPlaybackRate = 0;
}
if ( !m_pRagdoll && m_nRestoreSequence != -1 )
{
m_nSequence = m_nRestoreSequence;
m_nRestoreSequence = -1;
}
if (updateType == DATA_UPDATE_CREATED)
{
m_nPrevSequence = -1;
m_nRestoreSequence = -1;
}
bool modelchanged = false;
// UNDONE: The base class does this as well. So this is kind of ugly
// but getting a model by index is pretty cheap...
const model_t *pModel = modelinfo->GetModel( GetModelIndex() );
if ( pModel != GetModel() )
{
modelchanged = true;
}
BaseClass::OnDataChanged( updateType );
if ( (updateType == DATA_UPDATE_CREATED) || modelchanged )
{
ResetLatched();
}
// If there's a significant change, make sure the shadow updates
if ( modelchanged || (m_nSequence != m_nPrevSequence))
{
g_pClientShadowMgr->UpdateShadow( GetShadowHandle(), true );
m_nPrevSequence = m_nSequence;
}
// Only need to think if animating client side
if ( m_bClientSideAnimation )
{
// Check to see if we should reset our frame
if ( m_bClientSideFrameReset != m_bLastClientSideFrameReset )
{
m_flCycle = 0;
}
}
// build a ragdoll if necessary
if ( m_nRenderFX == kRenderFxRagdoll && !m_builtRagdoll )
{
MoveToLastReceivedPosition( true );
GetAbsOrigin();
ResetLatched();
BecomeRagdollOnClient();
}
if ( m_pRagdoll && m_nRenderFX != kRenderFxRagdoll )
{
ClearRagdoll();
}
// If ragdolling and get EF_NOINTERP, we probably were dead and are now respawning,
// don't do blend out of ragdoll at respawn spot.
if ( IsEffectActive( EF_NOINTERP ) &&
m_pRagdollInfo &&
m_pRagdollInfo->m_bActive )
{
// Just turn off ragdoll blending immediately.
m_pRagdollInfo->m_bActive = false;
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void C_BaseAnimating::AddEntity( void )
{
// Server says don't interpolate this frame, so set previous info to new info.
if ( IsEffectActive(EF_NOINTERP) )
{
ResetLatched();
}
BaseClass::AddEntity();
}
//-----------------------------------------------------------------------------
// Purpose: Get the index of the attachment point with the specified name
//-----------------------------------------------------------------------------
int C_BaseAnimating::LookupAttachment( const char *pAttachmentName )
{
studiohdr_t *hdr = GetModelPtr();
if ( !hdr )
{
return -1;
}
// NOTE: Currently, the network uses 0 to mean "no attachment"
// thus the client must add one to the index of the attachment
// UNDONE: Make the server do this too to be consistent.
return Studio_FindAttachment( hdr, pAttachmentName ) + 1;
}
//-----------------------------------------------------------------------------
// Purpose: Get a random index of an attachment point with the specified substring in its name
//-----------------------------------------------------------------------------
int C_BaseAnimating::LookupRandomAttachment( const char *pAttachmentNameSubstring )
{
studiohdr_t *hdr = GetModelPtr();
if ( !hdr )
{
return -1;
}
// NOTE: Currently, the network uses 0 to mean "no attachment"
// thus the client must add one to the index of the attachment
// UNDONE: Make the server do this too to be consistent.
return Studio_FindRandomAttachment( hdr, pAttachmentNameSubstring ) + 1;
}
void C_BaseAnimating::UpdateClientSideAnimation()
{
// Update client side animation
if ( m_bClientSideAnimation )
{
// latch old values
int flags = LATCH_ANIMATION_VAR;
OnLatchInterpolatedVariables( flags );
// move frame forward
FrameAdvance( gpGlobals->frametime );
}
if ( m_pRagdoll && ( m_nRenderFX != kRenderFxRagdoll ) )
{
ClearRagdoll();
}
}
void C_BaseAnimating::Simulate()
{
DoAnimationEvents();
BaseClass::Simulate();
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : IPhysicsObject
//-----------------------------------------------------------------------------
IPhysicsObject *C_BaseAnimating::VPhysicsGetObject( void )
{
if ( IsRagdoll() )
return m_pRagdoll->GetElement( m_lastPhysicsBone );
return NULL;
}
bool C_BaseAnimating::TestCollision( const Ray_t &ray, unsigned int fContentsMask, trace_t& tr )
{
if ( ray.m_IsRay && IsSolidFlagSet( FSOLID_CUSTOMRAYTEST ))
{
if (!TestHitboxes( ray, fContentsMask, tr ))
return true;
return tr.DidHit();
}
if ( !ray.m_IsRay && IsSolidFlagSet( FSOLID_CUSTOMBOXTEST ))
{
// What do we do if we've got custom collisions but we're tracing a box against us?
// Naturally, we throw up our hands, say we collided, but don't fill in trace info
return true;
}
// We shouldn't get here.
Assert(0);
return false;
}
// UNDONE: This almost works. The client entities have no control over their solid box
// Also they have no ability to expose FSOLID_ flags to the engine to force the accurate
// collision tests.
// Add those and the client hitboxes will be robust
bool C_BaseAnimating::TestHitboxes( const Ray_t &ray, unsigned int fContentsMask, trace_t& tr )
{
VPROF( "C_BaseAnimating::TestCollision" );
studiohdr_t *pStudioHdr = modelinfo->GetStudiomodel( GetModel() );
if (!pStudioHdr)
return false;
mstudiohitboxset_t *set = pStudioHdr->pHitboxSet( m_nHitboxSet );
if ( !set || !set->numhitboxes )
return false;
// Use vcollide for box traces.
if ( !ray.m_IsRay )
return false;
// This *has* to be true for the existing code to function correctly.
Assert( ray.m_StartOffset == vec3_origin );
int boneMask = BONE_USED_BY_HITBOX | BONE_USED_BY_ATTACHMENT;
studiocache_t *pcache = Studio_GetBoneCache( pStudioHdr, m_nSequence, m_flAnimTime, GetAbsAngles(), GetAbsOrigin(), boneMask );
if ( !pcache )
{
matrix3x4_t bonetoworld[MAXSTUDIOBONES];
// FIXME: Do I need to update m_CachedBoneFlags here?
SetupBones( bonetoworld, MAXSTUDIOBONES, boneMask, gpGlobals->curtime );
pcache = Studio_SetBoneCache( pStudioHdr, m_nSequence, m_flAnimTime, GetAbsAngles(), GetAbsOrigin(), boneMask, bonetoworld );
}
matrix3x4_t *hitboxbones[MAXSTUDIOBONES];
Studio_LinkHitboxCache( hitboxbones, pcache, pStudioHdr, set );
if ( TraceToStudio( ray, pStudioHdr, set, hitboxbones, fContentsMask, tr ) )
{
mstudiobbox_t *pbox = set->pHitbox( tr.hitbox );
mstudiobone_t *pBone = pStudioHdr->pBone(pbox->bone);
tr.surface.name = "**studio**";
tr.surface.flags = SURF_HITBOX;
tr.surface.surfaceProps = physprops->GetSurfaceIndex( pBone->pszSurfaceProp() );
m_lastPhysicsBone = tr.physicsbone;
}
return true;
}
//-----------------------------------------------------------------------------
// Purpose: Check sequence framerate
// Input : iSequence -
// Output : float
//-----------------------------------------------------------------------------
float C_BaseAnimating::GetSequenceCycleRate( int iSequence )
{
studiohdr_t *hdr = GetModelPtr();
if ( !hdr )
{
return 0.0f;
}
return Studio_CPS( hdr, iSequence, m_flPoseParameter );
}
float C_BaseAnimating::GetAnimTimeInterval( void ) const
{
#define MAX_ANIMTIME_INTERVAL 0.2f
float flInterval = min( gpGlobals->curtime - m_flAnimTime, MAX_ANIMTIME_INTERVAL );
return flInterval;
}
//=========================================================
// StudioFrameAdvance - advance the animation frame up some interval (default 0.1) into the future
//=========================================================
void C_BaseAnimating::StudioFrameAdvance()
{
if ( m_bClientSideAnimation )
return;
studiohdr_t *hdr = GetModelPtr();
if ( !hdr )
return;
bool watch = 0;//Q_strstr( hdr->name, "objects/human_obj_powerpack_build.mdl" ) ? true : false;
//if (!anim.prevanimtime)
//{
//anim.prevanimtime = m_flAnimTime = gpGlobals->curtime;
//}
// How long since last animtime
float flInterval = GetAnimTimeInterval();
if (flInterval <= 0.001)
{
// Msg("%s : %s : %5.3f (skip)\n", STRING(pev->classname), GetSequenceName( m_nSequence ), m_flCycle );
return;
}
//anim.prevanimtime = m_flAnimTime;
m_flCycle += flInterval * GetSequenceCycleRate( m_nSequence ) * m_flPlaybackRate;
m_flAnimTime = gpGlobals->curtime;
if ( watch )
{
Msg("%s %6.3f : %6.3f (%.3f)\n", GetClassname(), gpGlobals->curtime, m_flAnimTime, flInterval );
}
if (m_flCycle < 0.0 || m_flCycle >= 1.0)
{
if (m_bSequenceLoops)
m_flCycle -= (int)(m_flCycle);
else
m_flCycle = (m_flCycle < 0.0f) ? 0.0f : 1.0f;
m_bSequenceFinished = true; // just in case it wasn't caught in GetEvents
}
m_flGroundSpeed = GetSequenceGroundSpeed( m_nSequence );
if ( watch )
{
Msg("%s : %s : %5.1f\n", GetClassname(), GetSequenceName( m_nSequence ), m_flCycle );
}
}
float C_BaseAnimating::GetSequenceGroundSpeed( int iSequence )
{
float t = SequenceDuration( iSequence );
if (t > 0)
{
return GetSequenceMoveDist( iSequence ) / t;
}
else
{
return 0;
}
}
//-----------------------------------------------------------------------------
// Purpose:
//
// Input : iSequence -
//
// Output : float
//-----------------------------------------------------------------------------
float C_BaseAnimating::GetSequenceMoveDist( int iSequence )
{
Vector vecReturn;
::GetSequenceLinearMotion( GetModelPtr(), iSequence, m_flPoseParameter, &vecReturn );
return vecReturn.Length();
}
//-----------------------------------------------------------------------------
// Purpose:
//
// Input : iSequence -
// *pVec -
//
//-----------------------------------------------------------------------------
void C_BaseAnimating::GetSequenceLinearMotion( int iSequence, Vector *pVec )
{
::GetSequenceLinearMotion( GetModelPtr(), iSequence, m_flPoseParameter, pVec );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : flInterval -
// Output : float
//-----------------------------------------------------------------------------
float C_BaseAnimating::FrameAdvance( float flInterval )
{
studiohdr_t *hdr = GetModelPtr();
if ( !hdr )
return 0.0f;
bool watch = false; // Q_strstr( hdr->name, "commando" ) ? true : false;
float curtime = gpGlobals->curtime;
if (flInterval == 0.0)
{
flInterval = ( curtime - m_flAnimTime );
if (flInterval <= 0.001)
{
m_flAnimTime = curtime;
return 0.0;
}
}
if (! m_flAnimTime)
flInterval = 0.0;
float cyclerate = GetSequenceCycleRate( m_nSequence );
float addcycle = flInterval * cyclerate * m_flPlaybackRate;
m_flCycle += addcycle;
//m_iv_flCycle.NoteChanged( this, LATCH_ANIMATION_VAR, gpGlobals->curtime );
m_flAnimTime = curtime;
if ( watch )
{
Msg("%i CLIENT Time: %6.3f : (Interval %f) : cycle %f rate %f add %f\n",
gpGlobals->tickcount,
gpGlobals->curtime,
flInterval,
m_flCycle,
cyclerate,
addcycle );
}
if (m_flCycle < 0.0 || m_flCycle >= 1.0)
{
bool seqloops = IsSequenceLooping( m_nSequence );
if (seqloops)
{
m_flCycle -= (int)(m_flCycle);
}
else
{
m_flCycle = (m_flCycle < 0.0) ? 0 : 1.0f;
}
}
return flInterval;
}
BEGIN_PREDICTION_DATA( C_BaseAnimating )
DEFINE_PRED_FIELD( C_BaseAnimating, m_nSkin, FIELD_INTEGER, FTYPEDESC_INSENDTABLE ),
DEFINE_PRED_FIELD( C_BaseAnimating, m_nBody, FIELD_INTEGER, FTYPEDESC_INSENDTABLE ),
// DEFINE_PRED_FIELD( C_BaseAnimating, m_nHitboxSet, FIELD_INTEGER, FTYPEDESC_INSENDTABLE ),
DEFINE_PRED_FIELD( C_BaseAnimating, m_flModelScale, FIELD_FLOAT, FTYPEDESC_INSENDTABLE ),
DEFINE_PRED_FIELD( C_BaseAnimating, m_nSequence, FIELD_INTEGER, FTYPEDESC_INSENDTABLE | FTYPEDESC_NOERRORCHECK ),
DEFINE_PRED_FIELD( C_BaseAnimating, m_flPlaybackRate, FIELD_FLOAT, FTYPEDESC_INSENDTABLE | FTYPEDESC_NOERRORCHECK ),
DEFINE_PRED_FIELD( C_BaseAnimating, m_flCycle, FIELD_FLOAT, FTYPEDESC_INSENDTABLE | FTYPEDESC_NOERRORCHECK ),
// DEFINE_PRED_ARRAY( C_BaseAnimating, m_flPoseParameter, FIELD_FLOAT, MAXSTUDIOPOSEPARAM, FTYPEDESC_INSENDTABLE ),
DEFINE_PRED_ARRAY_TOL( C_BaseAnimating, m_flEncodedController, FIELD_FLOAT, MAXSTUDIOBONECTRLS, FTYPEDESC_INSENDTABLE, 0.02f ),
DEFINE_FIELD( C_BaseAnimating, m_nPrevSequence, FIELD_INTEGER ),
//DEFINE_FIELD( C_BaseAnimating, m_flPrevEventCycle, FIELD_FLOAT ),
//DEFINE_FIELD( C_BaseAnimating, m_flEventCycle, FIELD_FLOAT ),
//DEFINE_FIELD( C_BaseAnimating, m_nEventSequence, FIELD_INTEGER ),
DEFINE_PRED_FIELD( C_BaseAnimating, m_nNewSequenceParity, FIELD_INTEGER, FTYPEDESC_INSENDTABLE ),
DEFINE_PRED_FIELD( C_BaseAnimating, m_nResetEventsParity, FIELD_INTEGER, FTYPEDESC_INSENDTABLE ),
//DEFINE_FIELD( C_BaseAnimating, m_nPrevNewSequenceParity, FIELD_INTEGER ),
//DEFINE_FIELD( C_BaseAnimating, m_nPrevResetEventsParity, FIELD_INTEGER ),
// DEFINE_PRED_FIELD( C_BaseAnimating, m_vecForce, FIELD_VECTOR, FTYPEDESC_INSENDTABLE ),
// DEFINE_PRED_FIELD( C_BaseAnimating, m_nForceBone, FIELD_INTEGER, FTYPEDESC_INSENDTABLE ),
// DEFINE_PRED_FIELD( C_BaseAnimating, m_bClientSideAnimation, FIELD_BOOLEAN, FTYPEDESC_INSENDTABLE ),
// DEFINE_PRED_FIELD( C_BaseAnimating, m_bClientSideFrameReset, FIELD_BOOLEAN, FTYPEDESC_INSENDTABLE ),
// DEFINE_FIELD( C_BaseAnimating, m_pRagdollInfo, RagdollInfo_t ),
// DEFINE_FIELD( C_BaseAnimating, m_CachedBones, CUtlVector < CBoneCacheEntry > ),
// DEFINE_FIELD( C_BaseAnimating, m_pActualAttachmentAngles, FIELD_VECTOR ),
// DEFINE_FIELD( C_BaseAnimating, m_pActualAttachmentOrigin, FIELD_VECTOR ),
// DEFINE_FIELD( C_BaseAnimating, m_animationQueue, CUtlVector < AnimationLayer_t > ),
// DEFINE_FIELD( C_BaseAnimating, m_pIk, CIKContext ),
// DEFINE_FIELD( C_BaseAnimating, m_bLastClientSideFrameReset, FIELD_BOOLEAN ),
// DEFINE_FIELD( C_BaseAnimating, hdr, studiohdr_t ),
// DEFINE_FIELD( C_BaseAnimating, m_pRagdoll, IRagdoll ),
// DEFINE_FIELD( C_BaseAnimating, m_lastPhysicsBone, FIELD_INTEGER ),
// DEFINE_FIELD( C_BaseAnimating, m_bStoreRagdollInfo, FIELD_BOOLEAN ),
END_PREDICTION_DATA()
// Stubs for weapon prediction
void C_BaseAnimating::ResetSequenceInfo( void )
{
if (m_nSequence == -1)
{
// This shouldn't happen. Setting m_nSequence blindly is a horrible coding practice.
m_nSequence = 0;
}
m_flGroundSpeed = GetSequenceGroundSpeed( m_nSequence );
m_bSequenceLoops = IsSequenceLooping( m_nSequence );
// m_flAnimTime = gpGlobals->time;
m_flPlaybackRate = 1.0;
m_bSequenceFinished = false;
m_flLastEventCheck = 0;
m_nNewSequenceParity = ( ++m_nNewSequenceParity ) & EF_PARITY_MASK;
m_nResetEventsParity = ( ++m_nResetEventsParity ) & EF_PARITY_MASK;
}
//=========================================================
//=========================================================
int C_BaseAnimating::GetSequenceFlags( int iSequence )
{
return ::GetSequenceFlags( GetModelPtr(), iSequence );
}
bool C_BaseAnimating::IsSequenceLooping( int iSequence )
{
return (GetSequenceFlags( iSequence ) & STUDIO_LOOPING) != 0;
}
float C_BaseAnimating::SequenceDuration( int iSequence )
{
studiohdr_t *hdr = GetModelPtr();
if ( !hdr )
{
return 0.1f;
}
studiohdr_t* pstudiohdr = hdr;
if (iSequence >= pstudiohdr->numseq || iSequence < 0 )
{
DevWarning( 2, "C_BaseAnimating::SequenceDuration( %d ) out of range\n", iSequence );
return 0.1;
}
return Studio_Duration( pstudiohdr, iSequence, m_flPoseParameter );
}
int C_BaseAnimating::FindTransitionSequence( int iCurrentSequence, int iGoalSequence, int *piDir )
{
studiohdr_t *hdr = GetModelPtr();
if ( !hdr )
{
return -1;
}
if (piDir == NULL)
{
int iDir = 1;
int sequence = ::FindTransitionSequence( hdr, iCurrentSequence, iGoalSequence, &iDir );
if (iDir != 1)
return -1;
else
return sequence;
}
return ::FindTransitionSequence( hdr, iCurrentSequence, iGoalSequence, piDir );
}
void C_BaseAnimating::SetBodygroup( int iGroup, int iValue )
{
Assert( GetModelPtr() );
::SetBodygroup( GetModelPtr( ), m_nBody, iGroup, iValue );
}
int C_BaseAnimating::GetBodygroup( int iGroup )
{
Assert( GetModelPtr() );
return ::GetBodygroup( GetModelPtr( ), m_nBody, iGroup );
}
const char *C_BaseAnimating::GetBodygroupName( int iGroup )
{
Assert( GetModelPtr() );
return ::GetBodygroupName( GetModelPtr( ), iGroup );
}
int C_BaseAnimating::FindBodygroupByName( const char *name )
{
Assert( GetModelPtr() );
return ::FindBodygroupByName( GetModelPtr( ), name );
}
int C_BaseAnimating::GetBodygroupCount( int iGroup )
{
Assert( GetModelPtr() );
return ::GetBodygroupCount( GetModelPtr( ), iGroup );
}
int C_BaseAnimating::GetNumBodyGroups( void )
{
Assert( GetModelPtr() );
return ::GetNumBodyGroups( GetModelPtr( ) );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : setnum -
//-----------------------------------------------------------------------------
void C_BaseAnimating::SetHitboxSet( int setnum )
{
#ifdef _DEBUG
studiohdr_t *pStudioHdr = GetModelPtr();
if ( !pStudioHdr )
return;
if (setnum > pStudioHdr->numhitboxsets)
{
// Warn if an bogus hitbox set is being used....
static bool s_bWarned = false;
if (!s_bWarned)
{
Warning("Using bogus hitbox set in entity %s!\n", GetClassname() );
s_bWarned = true;
}
setnum = 0;
}
#endif
m_nHitboxSet = setnum;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *setname -
//-----------------------------------------------------------------------------
void C_BaseAnimating::SetHitboxSetByName( const char *setname )
{
m_nHitboxSet = FindHitboxSetByName( GetModelPtr(), setname );
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : int
//-----------------------------------------------------------------------------
int C_BaseAnimating::GetHitboxSet( void )
{
return m_nHitboxSet;
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : char const
//-----------------------------------------------------------------------------
const char *C_BaseAnimating::GetHitboxSetName( void )
{
return ::GetHitboxSetName( GetModelPtr(), m_nHitboxSet );
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : int
//-----------------------------------------------------------------------------
int C_BaseAnimating::GetHitboxSetCount( void )
{
return ::GetHitboxSetCount( GetModelPtr() );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : activity -
// Output : int C_BaseAnimating::SelectWeightedSequence
//-----------------------------------------------------------------------------
int C_BaseAnimating::SelectWeightedSequence ( int activity )
{
Assert( activity != ACT_INVALID );
return ::SelectWeightedSequence( GetModelPtr(), activity );
}
//=========================================================
//=========================================================
int C_BaseAnimating::LookupPoseParameter( const char *szName )
{
studiohdr_t *pstudiohdr = GetModelPtr( );
if ( !pstudiohdr )
{
return 0;
}
for (int i = 0; i < pstudiohdr->numposeparameters; i++)
{
if (stricmp( pstudiohdr->pPoseParameter( i )->pszName(), szName ) == 0)
{
return i;
}
}
// AssertMsg( 0, UTIL_VarArgs( "poseparameter %s couldn't be mapped!!!\n", szName ) );
return -1; // Error
}
//=========================================================
//=========================================================
float C_BaseAnimating::SetPoseParameter( const char *szName, float flValue )
{
return SetPoseParameter( LookupPoseParameter( szName ), flValue );
}
float C_BaseAnimating::SetPoseParameter( int iParameter, float flValue )
{
studiohdr_t *pstudiohdr = GetModelPtr( );
if ( !pstudiohdr )
{
Assert(!"C_BaseAnimating::SetPoseParameter: model missing");
return flValue;
}
if (iParameter >= 0)
{
float flNewValue;
flValue = Studio_SetPoseParameter( pstudiohdr, iParameter, flValue, flNewValue );
m_flPoseParameter[ iParameter ] = flNewValue;
}
return flValue;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *label -
// Output : int
//-----------------------------------------------------------------------------
int C_BaseAnimating::LookupSequence( const char *label )
{
Assert( GetModelPtr() );
return ::LookupSequence( GetModelPtr(), label );
}
void C_BaseAnimating::Release()
{
ClearRagdoll();
BaseClass::Release();
}
//-----------------------------------------------------------------------------
// Purpose: Clear current ragdoll
//-----------------------------------------------------------------------------
void C_BaseAnimating::ClearRagdoll()
{
if ( m_pRagdoll )
{
delete m_pRagdoll;
m_pRagdoll = NULL;
// If we have ragdoll mins/maxs, we've just come out of ragdoll, so restore them
if ( m_vecPreRagdollMins != vec3_origin || m_vecPreRagdollMaxs != vec3_origin )
{
SetCollisionBounds( m_vecPreRagdollMins, m_vecPreRagdollMaxs );
Relink();
}
}
m_builtRagdoll = false;
}
//-----------------------------------------------------------------------------
// Purpose: Looks up an activity by name.
// Input : label - Name of the activity, ie "ACT_IDLE".
// Output : Returns the activity ID or ACT_INVALID.
//-----------------------------------------------------------------------------
int C_BaseAnimating::LookupActivity( const char *label )
{
Assert( GetModelPtr() );
return ::LookupActivity( GetModelPtr(), label );
}
//-----------------------------------------------------------------------------
// Purpose:
//
// Input : iSequence -
//
// Output : char
//-----------------------------------------------------------------------------
const char *C_BaseAnimating::GetSequenceActivityName( int iSequence )
{
if( iSequence == -1 )
{
return "Not Found!";
}
if ( !GetModelPtr() )
return "No model!";
return ::GetSequenceActivityName( GetModelPtr(), iSequence );
}
//=========================================================
//=========================================================
float C_BaseAnimating::SetBoneController ( int iController, float flValue )
{
Assert( GetModelPtr() );
studiohdr_t *pmodel = (studiohdr_t*)GetModelPtr();
Assert(iController >= 0 && iController < NUM_BONECTRLS);
float controller = m_flEncodedController[iController];
float retVal = Studio_SetController( pmodel, iController, flValue, controller );
m_flEncodedController[iController] = controller;
return retVal;
}
//-----------------------------------------------------------------------------
// Purpose:
//
// Input : iSequence -
//
// Output : char
//-----------------------------------------------------------------------------
const char *C_BaseAnimating::GetSequenceName( int iSequence )
{
if( iSequence == -1 )
{
return "Not Found!";
}
if ( !GetModelPtr() )
return "No model!";
return ::GetSequenceName( GetModelPtr(), iSequence );
}
Activity C_BaseAnimating::GetSequenceActivity( int iSequence )
{
if( iSequence == -1 )
{
return ACT_INVALID;
}
if ( !GetModelPtr() )
return ACT_INVALID;
return (Activity)::GetSequenceActivity( GetModelPtr(), iSequence );
}
//-----------------------------------------------------------------------------
// Purpose: Clientside bone follower class. Used just to visualize them.
// Bone followers WON'T be sent to the client if VISUALIZE_FOLLOWERS is
// undefined in the server's physics_bone_followers.cpp
//-----------------------------------------------------------------------------
class C_BoneFollower : public C_BaseEntity
{
DECLARE_CLASS( C_BoneFollower, C_BaseEntity );
DECLARE_CLIENTCLASS();
public:
C_BoneFollower( void )
{
}
bool ShouldDraw( void );
int DrawModel( int flags );
private:
int m_modelIndex;
int m_solidIndex;
};
IMPLEMENT_CLIENTCLASS_DT( C_BoneFollower, DT_BoneFollower, CBoneFollower )
RecvPropInt( RECVINFO( m_modelIndex ) ),
RecvPropInt( RECVINFO( m_solidIndex ) ),
END_RECV_TABLE()
//-----------------------------------------------------------------------------
// Purpose: Returns whether object should render.
//-----------------------------------------------------------------------------
bool C_BoneFollower::ShouldDraw( void )
{
return ( vcollide_wireframe.GetBool() );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int C_BoneFollower::DrawModel( int flags )
{
vcollide_t *pCollide = modelinfo->GetVCollide( m_modelIndex );
if ( pCollide )
{
static color32 debugColor = {0,255,255,0};
matrix3x4_t matrix;
AngleMatrix( GetAbsAngles(), GetAbsOrigin(), matrix );
engine->DebugDrawPhysCollide( pCollide->solids[m_solidIndex], NULL, matrix, debugColor );
}
return 1;
} | [
"houontherun@gmail.com"
] | houontherun@gmail.com |
e500a814fe5840837fb3027b8d80de131209dcc6 | b172197c2dbff626220856d59ef8262125a92566 | /pat1040eng.h | f30fd7b626c7e953dd956f7581a154d9b5c110fe | [
"Apache-2.0"
] | permissive | hqnjkkl/patAnswers | da56583677edf048280a7aee307203a7d8615df2 | 32586a9708318979bf1566fc5b3c22d3498b7004 | refs/heads/master | 2021-01-01T05:42:05.111377 | 2019-02-02T11:39:02 | 2019-02-02T11:39:02 | 23,617,448 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 278 | h | //
// pat1040eng.h
// acmProject
//
// Created by HuQiaoNan on 14-7-11.
// Copyright (c) 2014年 HuQiaoNan. All rights reserved.
//
#ifndef __acmProject__pat1040eng__
#define __acmProject__pat1040eng__
#include <iostream>
#endif /* defined(__acmProject__pat1040eng__) */
| [
"huqiaonan@MacBook-Pro.local"
] | huqiaonan@MacBook-Pro.local |
2d741d191b8d0aed205196db57ad0870f9cf627e | 5eace6c1fc699d5eb85c49269d17d963d430dda6 | /sport_prog/FebCook/rowcolop.cpp | 75f660487cd1f2457bb8f1fa999093b08ee93061 | [] | no_license | shashwat001/my-codes | 87fd8f508f039e621cc971072ac39d9f2d1d1851 | f9db0a7c13c2689fde1b770bc0edfa092dc62ee9 | refs/heads/master | 2021-09-20T06:22:23.993687 | 2018-08-05T19:00:48 | 2018-08-05T19:00:48 | 5,686,297 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 357 | cpp | #include <stdio.h>
int main()
{
int r[1000000]={0},c[1000000] = {0},n,q,i,maxc = 0,maxr = 0,k,l;
char str[100];
scanf("%d %d",&n,&q);
while(q--)
{
scanf("%s %d %d",str,&k,&l);
if(str[0] == 'R')
{
r[k] += l;
if(r[k] > maxr)
maxr = r[k];
}
else
{
c[k] += l;
if(c[k] > maxc)
maxc = c[k];
}
}
printf("%d",maxr+maxc);
}
| [
"user@cs-lb-60.cse.iitkgp.ernet.in"
] | user@cs-lb-60.cse.iitkgp.ernet.in |
47c0ecf0567ac03a54b0b04fc1d5d12d2db874c6 | 249b8ac66022cef45f1e5fd8d594b76ee0cb3ad4 | /Working/oldDSMC/dsmcShockTube/processor3/0.01/fD | ced5b7c502c0e192514eef60fd5b0e87f38d344e | [] | no_license | Anthony-Gay/HPC_workspace | 2a3da1d599a562f2820269cc36a997a2b16fcbb8 | 41ef65d7ed3977418f360a52c2d8ae681e1b3971 | refs/heads/master | 2021-07-13T17:36:50.352775 | 2021-02-08T05:59:49 | 2021-02-08T05:59:49 | 232,433,074 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 993 | /*--------------------------------*- C++ -*----------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Version: 7
\\/ M anipulation |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class volVectorField;
location "0.01";
object fD;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
dimensions [1 -1 -2 0 0 0 0];
internalField uniform (0 0 0);
boundaryField
{
sides
{
type symmetry;
}
empty
{
type empty;
}
procBoundary3to2
{
type processor;
value uniform (0 0 0);
}
}
// ************************************************************************* //
| [
"anthonygay1812@yahoo.com"
] | anthonygay1812@yahoo.com | |
837e7dd6862a1fcd82668063bd067057730a56bc | fe63b9633e72f32120624044dc288d336f3d5c76 | /SemGridsMakerArduino/LINAC 3/Grille_ITLBSF03HVITMBSF04HV_Vertical/Grille_ITLBSF03HVITMBSF04HV_Vertical.ino | 570038a22f19fe3b66edc9938e02af21cfcb2a2e | [] | no_license | guilhemelias/SemGrids-Maker | 179abf3455f6efab048278d7feda98487d155429 | f13d3126fa73e7d418a78b4f6ca0555f34f143fb | refs/heads/main | 2023-05-15T20:45:37.365910 | 2021-06-14T11:36:24 | 2021-06-14T11:36:24 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 8,940 | ino | //Programme pour grille ITLBSF03HVITMBSF04HV_Vertical
#include "AccelStepper.h"
//#include <time.h>
AccelStepper stepper(1,10,8);
//motor 1
int M1_EN = 1;
int M1_pwm = 52;
int M1_dir = 53;
int M1_com = 5;
//motor 2
int M2_EN = 9;
int M2_pwm = 10;
int M2_dir = 8;
//motor 1 paramiters
int M1_max_speed = 1400; // steps per second // steps per second second
int M1_min_speed = 400;
//motor 2 paramiters
int M2_max_speed = 4000; // steps per second
int M2_max_acc = 1000; // steps per second second
int M2_min_speed = 1000;
int M1_stepsPer_Rot = 3200; //steps per rotation
int M2_stepsPer_Rot = 3200; //steps per rotation
//Repartition de la grillegrille ITLBSF03HV_Vertical
int a_tour=8;
float a_pas=1.6;//5 tour -> pas de 1.7
int b_tour=14;
float b_pas=1;//7 tour -> pas de 1mm
int c_tour=8;
float c_pas=1.6;//6 tour -> pas de 1.7mm
int pos = 0;
int dir=-1; //choix de la direction de la glissiere
//1=vers la gauche ; -1=vers la droite
float mm_deplacee=a_tour*a_pas*b_tour*b_pas*c_tour*c_pas;
int delaymotor=5; //duree de la pause entre chaque pas --> inversement proportionnelle a la vitesse
void setup()
{
// motor 1
pinMode(M1_com, OUTPUT);
pinMode(M1_EN, OUTPUT);
pinMode(M1_pwm, OUTPUT);
pinMode(M1_dir, OUTPUT);
//motor2
pinMode(M2_EN, OUTPUT);
pinMode(M2_pwm, OUTPUT);
pinMode(M2_dir, OUTPUT);
digitalWrite(M1_com, HIGH);
digitalWrite(M1_EN, LOW); // enable motor
//establish motor direction toggle pins
pinMode(12, OUTPUT); //CH A -- HIGH = forwards and LOW = backwards???
pinMode(13, OUTPUT); //CH B -- HIGH = forwards and LOW = backwards???
//establish motor brake pins
pinMode(9, OUTPUT); //brake (disable) CH A
pinMode(8, OUTPUT); //brake (disable) CH B
}
void loop() {
delay(2000); //pause de 2s
int dir = 1;
move(3200, 25, 1, -1, -1 * dir); //1er tour d'initialisation
int a=0;
while (a<a_tour) { //debut de la boucle pour pas a
GlisCW10(delaymotor);
float pas=a_pas*25;
move(3200, pas, 1, -1, 1 * dir);
a++;
}
int b=0;
while (b<b_tour) { //debut de la boucle pour pas b
float pas=b_pas*25;
move(3200, pas, 1, -1, 1 * dir);
b++;
}
int c = 0;
while (c<c_tour) { //debut de la boucle pour pas c
GlisCW10(delaymotor);
float pas=c_pas*25;
move(3200, pas, 1, -1, 1 * dir);
c++;
}
move(3200, 25, 1, -1, 1 * dir); //dernier tour de finalisation
move(3200, 25, 1, -1, 1 * dir); //dernier tour de finalisation
while(-1){} //fin du programme
}
long int delaytime(int maxvel, int min_value, int currentStep) { // consigne sinusoidale du moteur
double avrg_val = 1.0*(maxvel - min_value) / 2.0;
double val = avrg_val*sin(currentStep/(3.14159*80)+(3*3.14159/2)) + (avrg_val+ min_value);
//convert to time
//Serial.print(currentStep);
//Serial.print("%");
//Serial.print(M1_stepsPer_Rot);
//Serial.print("=");
//Serial.println(currentStep%M1_stepsPer_Rot);
Serial.println(val);
//Serial.println(1e6 / val);
////return 10000;
return (int)(1e6*(1.0/val));
}
void takeStep(int pwm1, long int dely, int dirpin, int dir) { //programme pas a pas du moteur cadre
if (dir >= 1)
digitalWrite(dirpin, HIGH);
else digitalWrite(dirpin, LOW);
digitalWrite(pwm1, HIGH);
delayMicroseconds(dely);
digitalWrite(pwm1, LOW);
delayMicroseconds(dely);
}
void GlisCCW(int delaylegnth) //programme du moteur glissiere sens "COUNTERCLOCKWISE"
{
digitalWrite(9, LOW); //ENABLE CH A
digitalWrite(8, HIGH); //DISABLE CH B
digitalWrite(12, HIGH); //Sets direction of CH A
analogWrite(3, 255); //Moves CH A
delay(delaylegnth);
digitalWrite(9, HIGH); //DISABLE CH A
digitalWrite(8, LOW); //ENABLE CH B
digitalWrite(13, LOW); //Sets direction of CH B
analogWrite(11, 255); //Moves CH B
delay(delaylegnth);
digitalWrite(9, LOW); //ENABLE CH A
digitalWrite(8, HIGH); //DISABLE CH B
digitalWrite(12, LOW); //Sets direction of CH A
analogWrite(3, 255); //Moves CH A
delay(delaylegnth);
digitalWrite(9, HIGH); //DISABLE CH A
digitalWrite(8, LOW); //ENABLE CH B
digitalWrite(13, HIGH); //Sets direction of CH B
analogWrite(11, 255); //Moves CH B
delay(delaylegnth);
}
void GlisCW(int delaylegnth){ //programme du moteur glissiere sens "CLOCKWISE"
digitalWrite(9, LOW); //ENABLE CH A
digitalWrite(8, HIGH); //DISABLE CH B
digitalWrite(12, HIGH); //Sets direction of CH A
analogWrite(3, 255); //Moves CH A
delay(delaylegnth);
digitalWrite(9, HIGH); //DISABLE CH A
digitalWrite(8, LOW); //ENABLE CH B
digitalWrite(13, HIGH); //Sets direction of CH B
analogWrite(11, 255); //Moves CH B
delay(delaylegnth);
digitalWrite(9, LOW); //ENABLE CH A
digitalWrite(8, HIGH); //DISABLE CH B
digitalWrite(12, LOW); //Sets direction of CH A
analogWrite(3, 255); //Moves CH A
delay(delaylegnth);
digitalWrite(9, HIGH); //DISABLE CH A
digitalWrite(8, LOW); //ENABLE CH B
digitalWrite(13, LOW); //Sets direction of CH B
analogWrite(11, 255); //Moves CH B
delay(delaylegnth);
}
void GlisCW10(int delaylegnth){ //programme du moteur glissiere sens "CLOCKWISE_10mm"
digitalWrite(9, LOW); //ENABLE CH A
digitalWrite(8, HIGH); //DISABLE CH B
digitalWrite(12, LOW); //Sets direction of CH A
analogWrite(3, 255); //Moves CH A
delay(delaylegnth);
digitalWrite(9, HIGH); //DISABLE CH A
digitalWrite(8, LOW); //ENABLE CH B
digitalWrite(13, LOW); //Sets direction of CH B
analogWrite(11, 255); //Moves CH B
delay(delaylegnth);
digitalWrite(9, LOW); //ENABLE CH A
digitalWrite(8, HIGH); //DISABLE CH B
digitalWrite(12, HIGH); //Sets direction of CH A
analogWrite(3, 255); //Moves CH A
delay(delaylegnth);
digitalWrite(9, HIGH); //DISABLE CH A
digitalWrite(8, LOW); //ENABLE CH B
digitalWrite(13, HIGH); //Sets direction of CH B
analogWrite(11, 255); //Moves CH B
delay(delaylegnth);
digitalWrite(9, LOW); //ENABLE CH A
digitalWrite(8, HIGH); //DISABLE CH B
digitalWrite(12, LOW); //Sets direction of CH A
analogWrite(3, 255); //Moves CH A
delay(delaylegnth);
digitalWrite(9, HIGH); //DISABLE CH A
digitalWrite(8, LOW); //ENABLE CH B
digitalWrite(13, LOW); //Sets direction of CH B
analogWrite(11, 255); //Moves CH B
delay(delaylegnth);
digitalWrite(9, LOW); //ENABLE CH A
digitalWrite(8, HIGH); //DISABLE CH B
digitalWrite(12, HIGH); //Sets direction of CH A
analogWrite(3, 255); //Moves CH A
delay(delaylegnth);
digitalWrite(9, HIGH); //DISABLE CH A
digitalWrite(8, LOW); //ENABLE CH B
digitalWrite(13, HIGH); //Sets direction of CH B
analogWrite(11, 255); //Moves CH B
delay(delaylegnth);
digitalWrite(9, LOW); //ENABLE CH A
digitalWrite(8, HIGH); //DISABLE CH B
digitalWrite(12, LOW); //Sets direction of CH A
analogWrite(3, 255); //Moves CH A
delay(delaylegnth);
digitalWrite(9, HIGH); //DISABLE CH A
digitalWrite(8, LOW); //ENABLE CH B
digitalWrite(13, LOW); //Sets direction of CH B
analogWrite(11, 255); //Moves CH B
delay(delaylegnth);
}
void move(int Nsteps1, int Nsteps2, int ratio, int dir1, int dir2) {
int Nstepsdone1 = 0;
int Nstepsdone2 = 0;
//step 2 logic
bool step2 = true;
//stepping
int wileSteps1 = Nsteps1;
int wileSteps2 = Nsteps2;
// if (Nsteps1 < Nsteps2*(1.0/ratio)) wileSteps = Nsteps2;
while (Nstepsdone1 < wileSteps1) {
//motor 1
long int dely1 = delaytime(M1_max_speed, M1_min_speed, Nstepsdone1);
takeStep(M1_pwm, dely1, M1_dir, dir1);
Nstepsdone1++;
//ratio conditions
if (Nstepsdone1%ratio == 0 && step2 == true) {
//motor 2
GlisCW(delaymotor);
Nstepsdone2++;
if (Nstepsdone2 >= Nsteps2) step2 = false;
}
}
}
| [
"guilhem.elias@gmail.com"
] | guilhem.elias@gmail.com |
f7eb49ad6b816eee2bdf1f879a0176dcfd64bb61 | 278c2f8f69e6a6385bef27c243a8316b37219c83 | /day_05/ex03/Intern.cpp | 02b46dea30dd78073fd84317c201f65dd2351776 | [] | no_license | qdequele/PiscineCPP | ba03742c9b66d8b730d1deb3ec40992a7295584c | 7727545194629d0140ac949213b01a0562f5a555 | refs/heads/master | 2021-05-13T13:43:27.559160 | 2018-01-18T10:46:08 | 2018-01-18T10:46:08 | 116,715,051 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,649 | cpp | /* ************************************************************************** */
/* */
/* ::: :::::::: */
/* Intern.cpp :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: qdequele <qdequele@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2018/01/15 15:52:32 by qdequele #+# #+# */
/* Updated: 2018/01/15 17:04:41 by qdequele ### ########.fr */
/* */
/* ************************************************************************** */
#include "Intern.hpp"
Intern::Intern() {
}
Intern::Intern(Intern const & src) {
*this = src;
}
Intern::~Intern() {
}
Intern & Intern::operator=( Intern const & rhs ) {
if ( this != &rhs ) {
}
return *this;
}
Form * Intern::makeForm(std::string name, std::string target) {
Form* form = nullptr;
if (name == "presidential pardon") {
form = new PresidentialPardonForm(target);
} else if (name == "robotomy request") {
form = new RobotomyRequestForm(target);
} else if (name == "shrubbery creation") {
form = new ShrubberyCreationForm(target);
}
if (form == nullptr) {
std::cout << "Form \"" << name << "\" not found" << std::endl;
} else {
std::cout << "Intern creates " << form->getName() << std::endl;
}
return form;
}
| [
"quentin@dequelen.me"
] | quentin@dequelen.me |
26fac3d00574b47b992b5fe4727d42d2fda458f6 | 385491d72892497d45b9cd406a22243202652d69 | /ground_models/src/run_inv2_ground.cpp | 084b0bf773e3f6161c4422013a5780c33e181a78 | [] | no_license | Behrouz-Babaki/FactoredSCP | 89f4ef53e893f11ec3c0fd739217361fd64168f3 | 1a417e0164a6b64961a5e0653e55a973a3ffeef8 | refs/heads/master | 2021-01-21T19:44:50.433723 | 2017-07-12T11:20:40 | 2017-07-12T11:20:40 | 92,158,485 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,324 | cpp | #pragma GCC diagnostic ignored "-Wunused-local-typedefs"
#include <iostream>
#include <gecode/search.hh>
#include <cstdlib>
#include <sys/resource.h>
#include <ace_engine_cpp.hpp>
#ifdef USE_GIST
#include <gecode/gist.hh>
#endif //USE_GIST
#include "cm_options.h"
#include "inv2_ground.h"
#include "time_util.hpp"
using std::cin;
using std::cout;
using std::endl;
using std::cerr;
using Gecode::BAB;
using Gecode::Exception;
using Gecode::Search::Statistics;
using Gecode::Search::Options;
using Gecode::Search::TimeStop;
int main(int argc, char* argv[]) {
extern struct Cm_opt PROG_OPT;
getCmOptions(argc, argv);
try {
AceEngineCpp engine(PROG_OPT.ac_file, PROG_OPT.lm_file, 1, PROG_OPT.verbose);
// Create the problem
Inv2GModel* m = new Inv2GModel(engine, PROG_OPT);
double start = get_wall_time();
int sols = 0;
int timeout = PROG_OPT.timeout;
#ifdef USE_GIST
Gecode::Gist::Print<KnapsackGModel> p("Print solution");
Gecode::Gist::Options o;
o.c_d = 0; // disable recomputation
o.inspect.click(&p);
Gecode::Gist::bab(m, o);
#else
Options o;
o.c_d = 0; // disable recomputation
#endif //USE_GIST
if (timeout > 0)
o.stop = new TimeStop(timeout*1e3);
BAB<Inv2GModel> e(m, o);
double best_value = -1;
while (Inv2GModel* s = e.next()) {
sols++;
//s->print();
best_value = s->solution_value();
delete s;
}
if (timeout > 0) {
if (e.stopped())
cout << "search stopped" << endl;
else
cout << "solution found" << endl;
}
cout << "exputil: " << best_value << endl;
Statistics stats = e.statistics();
if (true) { // (opt.verbose() >= 0) {
cout << "Solver stats:"
<< " time: " << get_wall_time() - start
<< " sols: " << sols
<< " fails: " << stats.fail
<< " nodes: " << stats.node
<< " props: " << stats.propagate
<< endl;
}
delete m;
} catch (Exception e) {
cerr << "Something went wrong ...\n" << e.what() << endl;
}
return 0;
}
| [
"Behrouz.Babaki@cs.kuleuven.be"
] | Behrouz.Babaki@cs.kuleuven.be |
62f80c3857d8844aa9a3a423ceb62bd997592260 | 794c094903b8b6693b50e2164952ed1ddbb55fa3 | /modules/gas/functions/CfgFunctions.hpp | a12c9b51cc0992b8d34a26f8dfe407c73c57be90 | [
"MIT"
] | permissive | PiZZAD0X/Olsen-Framework-Arma-3 | a8acefedbf934a2fbb097c3690589a9b355aba47 | b5467ef6a6f9dd99fcee1b4d046219c524058e35 | refs/heads/master | 2022-09-22T01:19:33.280212 | 2022-08-25T19:50:29 | 2022-08-25T19:50:29 | 132,228,519 | 2 | 1 | MIT | 2020-04-11T01:28:46 | 2018-05-05T08:20:12 | SQF | UTF-8 | C++ | false | false | 261 | hpp | class COMPONENT {
tag = COMPONENT;
class GAS {
file = "modules\gas\functions\GAS";
class createHotZone {};
class fakeMission {};
class fireMission {};
class gasParticles {};
class gasZones {};
class jipSend {};
class vehicleSiren {};
};
};
| [
"eddy@em-creations.co.uk"
] | eddy@em-creations.co.uk |
dcf3468d94d2a9c8c9d3f109bbaad3663b2679c2 | 6f49cc2d5112a6b97f82e7828f59b201ea7ec7b9 | /dbswdbe/WdbeQMtpTpl1NModule.h | 49a8cd1b6c64a6311d2e8216d43be5a7096215ec | [
"MIT"
] | permissive | mpsitech/wdbe-WhizniumDBE | d3702800d6e5510e41805d105228d8dd8b251d7a | 89ef36b4c86384429f1e707e5fa635f643e81240 | refs/heads/master | 2022-09-28T10:27:03.683192 | 2022-09-18T22:04:37 | 2022-09-18T22:04:37 | 282,705,449 | 5 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 5,624 | h | /**
* \file WdbeQMtpTpl1NModule.h
* Dbs and XML wrapper for table TblWdbeQMtpTpl1NModule (declarations)
* \copyright (C) 2016-2020 MPSI Technologies GmbH
* \author Alexander Wirthmueller (auto-generation)
* \date created: 5 Dec 2020
*/
// IP header --- ABOVE
#ifndef WDBEQMTPTPL1NMODULE_H
#define WDBEQMTPTPL1NMODULE_H
#include <sbecore/Xmlio.h>
#if defined(SBECORE_MAR) || defined(SBECORE_MY)
#include <sbecore/MyDbs.h>
#endif
#if defined(SBECORE_PG)
#include <sbecore/PgDbs.h>
#endif
/**
* WdbeQMtpTpl1NModule: record of TblWdbeQMtpTpl1NModule
*/
class WdbeQMtpTpl1NModule {
public:
WdbeQMtpTpl1NModule(const Sbecore::ubigint qref = 0, const Sbecore::ubigint jref = 0, const Sbecore::uint jnum = 0, const Sbecore::ubigint ref = 0, const std::string stubRef = "");
public:
Sbecore::ubigint qref;
Sbecore::ubigint jref;
Sbecore::uint jnum;
Sbecore::ubigint ref;
std::string stubRef;
public:
void writeJSON(Json::Value& sup, bool jnumattr = false, bool shorttags = false);
void writeXML(xmlTextWriter* wr, std::string difftag = "", bool jnumattr = false, bool shorttags = false);
};
/**
* ListWdbeQMtpTpl1NModule: recordset of TblWdbeQMtpTpl1NModule
*/
class ListWdbeQMtpTpl1NModule {
public:
ListWdbeQMtpTpl1NModule();
ListWdbeQMtpTpl1NModule(const ListWdbeQMtpTpl1NModule& src);
~ListWdbeQMtpTpl1NModule();
void clear();
unsigned int size() const;
void append(WdbeQMtpTpl1NModule* rec);
ListWdbeQMtpTpl1NModule& operator=(const ListWdbeQMtpTpl1NModule& src);
public:
std::vector<WdbeQMtpTpl1NModule*> nodes;
public:
void writeJSON(Json::Value& sup, std::string difftag = "");
void writeXML(xmlTextWriter* wr, std::string difftag = "");
};
/**
* TblWdbeQMtpTpl1NModule: C++ wrapper for table TblWdbeQMtpTpl1NModule
*/
class TblWdbeQMtpTpl1NModule {
public:
TblWdbeQMtpTpl1NModule();
virtual ~TblWdbeQMtpTpl1NModule();
public:
virtual bool loadRecBySQL(const std::string& sqlstr, WdbeQMtpTpl1NModule** rec);
virtual Sbecore::ubigint loadRstBySQL(const std::string& sqlstr, const bool append, ListWdbeQMtpTpl1NModule& rst);
virtual Sbecore::ubigint insertRec(WdbeQMtpTpl1NModule* rec);
Sbecore::ubigint insertNewRec(WdbeQMtpTpl1NModule** rec = NULL, const Sbecore::ubigint jref = 0, const Sbecore::uint jnum = 0, const Sbecore::ubigint ref = 0, const std::string stubRef = "");
Sbecore::ubigint appendNewRecToRst(ListWdbeQMtpTpl1NModule& rst, WdbeQMtpTpl1NModule** rec = NULL, const Sbecore::ubigint jref = 0, const Sbecore::uint jnum = 0, const Sbecore::ubigint ref = 0, const std::string stubRef = "");
virtual void insertRst(ListWdbeQMtpTpl1NModule& rst);
virtual void updateRec(WdbeQMtpTpl1NModule* rec);
virtual void updateRst(ListWdbeQMtpTpl1NModule& rst);
virtual void removeRecByQref(Sbecore::ubigint qref);
virtual void removeRstByJref(Sbecore::ubigint jref);
virtual bool loadRecByQref(Sbecore::ubigint qref, WdbeQMtpTpl1NModule** rec);
virtual Sbecore::ubigint loadRstByJref(Sbecore::ubigint jref, const bool append, ListWdbeQMtpTpl1NModule& rst);
};
#if defined(SBECORE_MAR) || defined(SBECORE_MY)
/**
* MyWdbeQMtpTpl1NModule: C++ wrapper for table TblWdbeQMtpTpl1NModule (MySQL database)
*/
class MyTblWdbeQMtpTpl1NModule : public TblWdbeQMtpTpl1NModule, public Sbecore::MyTable {
public:
MyTblWdbeQMtpTpl1NModule();
~MyTblWdbeQMtpTpl1NModule();
public:
void initStatements();
public:
MYSQL_STMT* stmtInsertRec;
MYSQL_STMT* stmtUpdateRec;
MYSQL_STMT* stmtRemoveRecByQref;
MYSQL_STMT* stmtRemoveRstByJref;
public:
bool loadRecBySQL(const std::string& sqlstr, WdbeQMtpTpl1NModule** rec);
Sbecore::ubigint loadRstBySQL(const std::string& sqlstr, const bool append, ListWdbeQMtpTpl1NModule& rst);
Sbecore::ubigint insertRec(WdbeQMtpTpl1NModule* rec);
void insertRst(ListWdbeQMtpTpl1NModule& rst);
void updateRec(WdbeQMtpTpl1NModule* rec);
void updateRst(ListWdbeQMtpTpl1NModule& rst);
void removeRecByQref(Sbecore::ubigint qref);
void removeRstByJref(Sbecore::ubigint jref);
bool loadRecByQref(Sbecore::ubigint qref, WdbeQMtpTpl1NModule** rec);
Sbecore::ubigint loadRstByJref(Sbecore::ubigint jref, const bool append, ListWdbeQMtpTpl1NModule& rst);
};
#endif
#if defined(SBECORE_PG)
/**
* PgWdbeQMtpTpl1NModule: C++ wrapper for table TblWdbeQMtpTpl1NModule (PgSQL database)
*/
class PgTblWdbeQMtpTpl1NModule : public TblWdbeQMtpTpl1NModule, public Sbecore::PgTable {
public:
PgTblWdbeQMtpTpl1NModule();
~PgTblWdbeQMtpTpl1NModule();
public:
void initStatements();
private:
bool loadRec(PGresult* res, WdbeQMtpTpl1NModule** rec);
Sbecore::ubigint loadRst(PGresult* res, const bool append, ListWdbeQMtpTpl1NModule& rst);
bool loadRecByStmt(const std::string& srefStmt, const unsigned int N, const char** vals, const int* l, const int* f, WdbeQMtpTpl1NModule** rec);
Sbecore::ubigint loadRstByStmt(const std::string& srefStmt, const unsigned int N, const char** vals, const int* l, const int* f, const bool append, ListWdbeQMtpTpl1NModule& rst);
public:
bool loadRecBySQL(const std::string& sqlstr, WdbeQMtpTpl1NModule** rec);
Sbecore::ubigint loadRstBySQL(const std::string& sqlstr, const bool append, ListWdbeQMtpTpl1NModule& rst);
Sbecore::ubigint insertRec(WdbeQMtpTpl1NModule* rec);
void insertRst(ListWdbeQMtpTpl1NModule& rst);
void updateRec(WdbeQMtpTpl1NModule* rec);
void updateRst(ListWdbeQMtpTpl1NModule& rst);
void removeRecByQref(Sbecore::ubigint qref);
void removeRstByJref(Sbecore::ubigint jref);
bool loadRecByQref(Sbecore::ubigint qref, WdbeQMtpTpl1NModule** rec);
Sbecore::ubigint loadRstByJref(Sbecore::ubigint jref, const bool append, ListWdbeQMtpTpl1NModule& rst);
};
#endif
#endif
| [
"aw@mpsitech.com"
] | aw@mpsitech.com |
6931e39074479ebe92a7e28e1e9d3ccaea2f25a6 | 5a02eac79d5b8590a88209dcc6cd5741323bb5de | /PAT/第一轮/未归档/A1073/main.cpp | 21d1f11ef1193c33e23fbc5f6daaa635b24651c4 | [] | no_license | qiatongxueshaonianC/CaiZebin-Code_warehouse | ddac8252afb207d9580856cfbb7e14f868432716 | 25e1f32c7d86d81327a0d9f08cd7462209e9fec2 | refs/heads/master | 2023-03-20T03:36:49.088871 | 2021-03-16T15:40:11 | 2021-03-16T15:40:11 | 348,395,087 | 0 | 0 | null | null | null | null | GB18030 | C++ | false | false | 663 | cpp | #include<bits/stdc++.h>
using namespace std;
string deal(string s){
int k=s.find('E');
char c=s[k+1];
int num=stoi(s.substr(k+2));
s.erase(k);
s.erase(2,1); //删点
// puts(s.c_str());
if(c=='+'){ //注意这里没判断当 num-(k-2-1)<0会抛出“运行时错误”
if(num-(k-2-1)>=0) s.insert(s.end(),num-(k-2-1),'0');
else s.insert(2+num,"."); // 处理这种特殊情况+1.23400E+01
}else{
s.insert(1,num,'0');
s.insert(2,".");
}
if(s[0]=='+')
s.erase(s.begin());
return s;
}
int main() {
string s;
getline(cin,s);
s=deal(s);
puts(s.c_str());
return 0;
}
/*
+1.23400E-03
+1.23400E+01
-1.23400E+01
-1.2E+10
-1.00E-00
*/
| [
"997018583@qq.com"
] | 997018583@qq.com |
e23faed74b9454c6dd0cec2a3b509d0538bd25ac | a66fa9ce1d449076ceb3dd41576539c9f7fbb005 | /num_net/sock_client.h | 91d1022a9b80eb0b79b169b216c0f00b7238032e | [] | no_license | chamlion/num_sort | d936735f15d82b8bf78c04926f68a05694b6289f | ae1e21e5a6f0a17f9f0d5ce2c622ece8d91ef916 | refs/heads/master | 2021-06-06T08:09:22.242860 | 2016-09-18T15:52:01 | 2016-09-18T15:52:01 | 67,101,818 | 2 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,184 | h | #ifndef SOCK_CLIENT_H
#define SOCK_CLIENT_H
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <memory>
#include <iostream>
#include<sstream>
#include<fstream>
#include<vector>
namespace num
{
typedef std::vector<struct epoll_event> EventList;
#define ERR_EXIT(m) \
do \
{ \
perror(m); \
exit(EXIT_FAILURE); \
} while(0)
class take_string_from_file //从文件中读取数据
{
public:
std::string s;
explicit take_string_from_file(std::string str)
{
fin.open(str,std::ios::in);
}
bool get_a_num()
{
if (getline(fin,s))
{
return true;
}
else
{
return false;
}
}
private:
std::ifstream fin;
};
class sock_client
{
public:
explicit sock_client(short port,std::string ip,std::string file_name):
port_(port),ip_(ip),file_name_(file_name)
{
sock_init();
}
void loop();
private:
int sock;
std::string file_name_;
struct sockaddr_in servaddr,localaddr;
socklen_t addrlen;
void sock_init();
short port_;
std::string ip_;
};
}
#endif
| [
"chamlionchina@gmail.com"
] | chamlionchina@gmail.com |
c4ecba7ef269259e13e397d5770941ff2ae3d685 | 27f33d2a63e607c0a4e4baaaa1f61d538f65d7e9 | /20. Reverse array.cpp | 96042a82e8b3e8db7fb9c530efe26e31b0846aaa | [] | no_license | Ajayt110/CPP | 348b8c9161a7089c514761121567c032f2604287 | ccfe985bf5d0028b0563d352400f18f4cdd4fb76 | refs/heads/master | 2022-12-13T12:54:46.138330 | 2020-09-09T13:44:19 | 2020-09-09T13:44:19 | 294,017,562 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 331 | cpp | #include<iostream>
using namespace std;
main()
{
int a[]={87,72,65,54,95,90,80,61,73,81,97,100},b[13],i;
cout<<"First Array:\n";
for(i=0;i<12;i++)
cout<<a[i]<<" ";
cout<<"\n";
for(i=0;i<12;i++)
{
b[11-i]=a[i];
}
cout<<"\nSecond Reverse Array:\n";
for(i=0;i<12;i++)
cout<<b[i]<<" ";
cout<<"\n";
}
| [
"noreply@github.com"
] | Ajayt110.noreply@github.com |
0a8e1a39422aad9e510168bc4e24aa71fe445a4a | 5261689e7c9114dfd89786358edc0a35e69ab57f | /cc-evenm.cpp | bdd59fa9f8beef6118f7f89132b090699c49479c | [] | no_license | shobhitkrsks/cp | bec5f36d5a8ff9684321099dc3244284f517ab43 | e551af079b4c1a4c1803b555ab9d3eec194910c5 | refs/heads/master | 2023-06-06T19:52:31.999545 | 2021-07-05T18:57:52 | 2021-07-05T18:57:52 | 248,814,534 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 690 | cpp | #include<iostream>
#include<bits/stdc++.h>
#define ll long long
using namespace std;
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int tc;
cin>>tc;
while(tc--)
{
int n;
cin>>n;
for (int i = 0; i < n; i++)
{
if(i%2==0)
{
for(int j=0;j<n;j++)
{
cout<<i*n+j+1<<" ";
}
}
else
{
for(int j=0;j<n;j++)
{
cout<<(i+1)*n-j<<" ";
}
}
cout<<"\n";
}
}
return 0;
} | [
"sks.shobhit12@gmail.com"
] | sks.shobhit12@gmail.com |
c28d7ec93786061c5a16289a8d61147765363b7c | fee530868e668f5c322acd23afb508059979784e | /Trees/Binary tree/main.cpp | aab2247eb3e37a4432910cfcf3738a11e3777f86 | [] | no_license | adityak3252/Ds-Algo | 2fe97cc2705e655bc40170cbf9e1043a802cbc06 | b074b371cc45178e29cd6842d53a4e4a91785bab | refs/heads/master | 2022-12-31T12:06:49.132833 | 2020-10-22T12:14:27 | 2020-10-22T12:14:27 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 10,822 | cpp | /*
classlocation.h -> traversal.h -> check.h -> summation.h -> other.h -> lca.h
*/
#include<bits/stdc++.h>
#include"lca.h"
typedef long long ll;
using namespace std;
void insertion(node **root,ll d)
{
node *tmproot=*root,*tmp=NULL;
//new node created
node *newnode=(node*)malloc(sizeof(node));
newnode->data=d;
newnode->l=newnode->r=NULL;
if(tmproot==NULL)//if tmproot is null means tree is empty
{
*root=newnode;
return;
}
queue<node*>q;//queue is created
q.push(tmproot);
while(!q.empty())
{
tmp=q.front();
q.pop();
if(tmp->l!=NULL)
q.push(tmp->l);
else
{
tmp->l=newnode;
queue<node*>emptyqueue;
swap(q,emptyqueue);
return;
}
if(tmp->r!=NULL)
q.push(tmp->r);
else
{
tmp->r=newnode;
queue<node*>emptyqueue;
swap(q,emptyqueue);
return;
}
}
}
int main()
{
system("color B0");
node *root=NULL;
ll opt,d,x;
while(1)
{
cout<<"\n1:Create tree\n2:Traversal\n3:ToCheck\n4:Summation\n5:Other\n6:LCA\n0:Exit\nOpt: ";
cin>>opt;
if(opt>6 || opt==0)
break;
switch(opt)
{
case 1:
cout<<"\nEnter count of values ";
cin>>x;
cout<<"\nEnter values: ";
while(x--)
{
cin>>d;
insertion(&root,d);
}
break;
case 2:
traversal(&root);
break;
case 5:
other(&root);
break;
}
}
}
/*
void nonrecursivePreorder(node *root)
{
node *tmp;
std::stack<node*>s;
while(1)
{
while(root!=nullptr)
{
cout<<root->data<<" ";
s.push(root);
root=root->l;
}
if(s.empty())
break;
root=s.top();
root=root->r;
s.pop();
}
}
void nonrecursiveIneorder(node *root)
{
node *tmp;
std::stack<node*>s;
while(1)
{
while(root!=nullptr)
{
s.push(root);
root=root->l;
}
if(s.empty())
break;
root=s.top();
cout<<root->data<<" ";
root=root->r;
s.pop();
}
}
//max function
int findmax(node* root)
{
int max=INT_MIN,ldata,rdata;
if(root)
{
ldata=findmax(root->l);
rdata=findmax(root->r);
if(ldata>rdata)
max=ldata;
else
max=rdata;
if(root->data>max)
max=root->data;
}
return max;
}
//max without recursion
int maxFind(node* root)
{
queue<node*>q;
node *tmp;
int max=INT_MIN;
if(root!=nullptr)
{
q.push(root);
// cout<<q.size();
while(!q.empty())
{
tmp=q.front();
q.pop();
if(tmp->data>max)
max=tmp->data;
// q.pop();
if(tmp->l)
q.push(tmp->l);
if(tmp->r)
q.push(tmp->r);
}
}
return max;
}
//search
bool Search(node* root,int s)
{
queue<node*>q;
node *tmp;
if(root!=nullptr)
{
q.push(root);
// cout<<q.size();
while(!q.empty())
{
tmp=q.front();
q.pop();
if(tmp->data==s)
return true;
// q.pop();
if(tmp->l)
q.push(tmp->l);
if(tmp->r)
q.push(tmp->r);
}
}
return false;
}
//size of tree
int sizeOfTree(node *root)
{
if(root)
{
return 1+sizeOfTree(root->l)+sizeOfTree(root->r);
}
}
//level order traversal
void levelOrder(node* root)
{
queue<node*>q;
node *tmp;
if(root!=nullptr)
{
q.push(root);
// cout<<q.size();
while(!q.empty())
{
tmp=q.front();
q.pop();
cout<<tmp->data<<" ";
// q.pop();
if(tmp->l)
q.push(tmp->l);
if(tmp->r)
q.push(tmp->r);
}
}
}
//levelOreder reverse
void levelOrederReverse(node *root)
{
//first insert left child in stack and then right child
node *tmp;
stack<int>s;
queue<node*>q;
if(root)
{
q.push(root);
while(!q.empty())
{
tmp=q.front();
s.push(tmp->data);
q.pop();
if(tmp->r)
q.push(tmp->r);
if(tmp->l)
q.push(tmp->l);
}
}
while(!s.empty())
{
cout<<s.top()<<" ";
s.pop();
}
}
//delete tree
void deleteTree(node* root)
{
if(root)
{
deleteTree(root->l);
deleteTree(root->r);
free(root);
}
}
//leaves count
int leavescount(node* root)
{
int cnt=1;
node *tmp;
queue<node*>q;
if(root)
{
q.push(root);
while(!q.empty())
{
tmp=q.front();
q.pop();
if(tmp->l ||tmp->r)
{
if(tmp->l)
q.push(tmp->l);
if(tmp->r)
q.push(tmp->r);
}
else//both child are not present
cnt++;
}
}
return cnt;
}
//count of complete node
int countFullNode(node* root)
{
int cnt=0;
node *tmp;
// here -1 represnt blank node
//example 2 node tree 1 as root and 2 as left child and right child is blank
// 1
// / \
// 2 -1
queue<node*>q;
if(root)
{
q.push(root);
while(!q.empty())
{
tmp=q.front();
q.pop();
if(tmp->l && tmp->r)
if(tmp->r->data!=-1 && tmp->l->data!=-1)
cnt++;
if(tmp->r)
q.push(tmp->r);
if(tmp->l)
q.push(tmp->l);
}
}
return cnt;
}
//count of half nodes
int countHalfNode(node* root)
{
int cnt=0;
node *tmp;
// here -1 represnt blank node
//example 2 node tree 1 as root and 2 as left child and right child is blank
// 1
// / \
// 2 -1
queue<node*>q;
if(root)
{
q.push(root);
while(!q.empty())
{
tmp=q.front();
q.pop();
if(tmp->l && tmp->r)
if(tmp->r->data!=-1 &&tmp->l->data==-1 || tmp->r->data==-1 &&tmp->l->data!=-1)
cnt++;
if(tmp->r)
q.push(tmp->r);
if(tmp->l)
q.push(tmp->l);
}
}
return cnt;
}
//delete node from b Tree
void deleteDeepNode(node* root,node* deepnode)//to delete deep node
{
queue<node*>q;
q.push(root);
node* tmp;
while(!q.empty())
{
tmp=q.front();
q.pop();
if(tmp==deepnode)
{
tmp=NULL;
free(tmp);
return;
}
if(tmp->l)
{
if(tmp->l==deepnode)
{
tmp->l=NULL;
free(deepnode);
return;
}
else
q.push(tmp->l) ;
}
if(tmp->r)
{
if(tmp->r==deepnode)
{
tmp->r=NULL;
free(deepnode);
return;
}
else
q.push(tmp->r) ;
}
}
}
node* deletenode(node *root,int d)//to find node to delete and deep node
{
if(root==NULL)
return NULL;
if(root->l==NULL && root->r==NULL)
{
if(root->data==d)
return NULL;
else
return root;
}
queue<node*>q;
node *deepnode,*todel;
q.push(root);
while(!q.empty())
{
deepnode=q.front();
q.pop();
if(deepnode->data==d)
todel=deepnode;
if(deepnode->l)
q.push(deepnode->l);
if(deepnode->r)
q.push(deepnode->r);
}
if(todel!=NULL)
{
int tmp=deepnode->data;//storing deep node data in temporary variable
deleteDeepNode(root,deepnode);//deleting deep node data
todel->data=tmp;//replacing data of node to be deleted by deep node data
}
return root;
//diameter of tree
int height(Node *root)//to find height
{
if(root==NULL)
return 0;
int l=height(root->left),r=height(root->right);
if(l>r)
return l+1;
return r+1;
}
int max(int a,int b)
{
if(a>b)
return a;
return b;
}
int diameter(Node* root)
{
if(root==NULL)
return 0;
int ans;
int hl=height(root->left),hr=height(root->right);
ans=max(hr+hl+1,max(diameter(root->left),diameter(root->right)));
//some times diameter not present at root so max of diameter of left and right subtree
return ans;
// Your code here
}
//Max sum for level
int levelMaxSum(node *root)
{
if(root==NULL)
return 0;
queue<node*>q;
node *tmp;
int sum=0,max=INT_MIN;
q.push(root);
int cnt=0;
while(!q.empty())
{
cnt=q.size();
sum=0;
while(cnt--)
{
tmp=q.front();
sum+=tmp->data;
if(tmp->l)
q.push(tmp->l);
if(tmp->r)
q.push(tmp->r);
q.pop();
}
if(sum>max)
max=sum;
}
return max;
}
//30)Modify a binary tree to get preorder traversal using right pointers only
void specifi_Level_Order(node *root)
{
if(root==NULL)
return;
node *curr1,*curr2=NULL;
std::queue<node*>q;
cout<<root->data<<" ";
if(root->l)
{
q.push(root->l);
// cout<<root->l->data<<" ";
}
if(root->r)
{
q.push(root->r);
// cout<<root->r->data<<" ";
}
while(!q.empty())
{
curr1=q.front();
q.pop();
curr2=q.front();
q.pop();
cout<<curr1->data<<" "<<curr2->data<<" ";
if(curr1->l)
{
q.push(curr1->l);
}
if(curr2->r)
{
q.push(curr2->r);
}
if(curr1->r)
{
q.push(curr1->r);
}
if(curr2->l)
{
q.push(curr2->l);
}
}
}
//27)density of binary tree
int density(node *root,int &size)
{
if(root==NULL)
return 0;
int lh=density(root->l);
int rh=density(root->r);
size++;
return l>r ? l+1:r+1;
}
*/
| [
"hrishibhagat8642@gmail.com"
] | hrishibhagat8642@gmail.com |
65d38b50b3fdd5c131306e98b4505f2b71886989 | b3839099049a5d34e14b2452c4969fd4f2a3333c | /src/shader_module.test.cpp | 8809e90f623a4c451c46c3880476e965915aff49 | [
"MIT"
] | permissive | jeffw387/vkaEngine | bb71827118929ec5aaa883e7bb41bbfbf26d0e22 | 69bc21d4c10229ab823a887147cb45888d9afbaf | refs/heads/master | 2021-07-08T19:07:34.049415 | 2019-02-24T06:53:45 | 2019-02-24T06:53:45 | 144,421,157 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 239 | cpp | #include "shader_module.hpp"
#include <catch2/catch.hpp>
#include "device.hpp"
#include "instance.hpp"
#include "move_into.hpp"
#include "physical_device.hpp"
#include "platform_glfw.hpp"
#include "queue_family.hpp"
using namespace vka;
| [
"jeffw387@gmail.com"
] | jeffw387@gmail.com |
906794a4b4f8ca249dfdef4df0dfcccdef3bbc14 | 45402c02083f5b768de4b28a79eb1d4f02cb1cce | /3/3.3.cpp | 7bb5f0756e0eb91df4017891936c58aee572245c | [
"MIT"
] | permissive | EricDoug/cpp1x-tutorial | 259885312749690a982566f16a441d00f9c5c4a9 | 8a3eb8f271eca3218ecc4ca69d2f94507425c964 | refs/heads/master | 2021-05-13T12:34:15.066573 | 2017-11-16T09:12:47 | 2017-11-16T09:12:47 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,200 | cpp | //
// 3.3.cpp
// c++1x tutorial
//
// created by changkun at shiyanlou.com
//
// 右值引用 rvalue reference
#include <iostream>
#include <string>
void reference(std::string& str) {
std::cout << "左值" << std::endl;
}
void reference(std::string&& str) {
std::cout << "右值" << std::endl;
}
int main()
{
std::string lv1 = "string,"; // lv1 是一个左值
// std::string&& r1 = s1; // 非法, 右值引用不能引用左值
std::string&& rv1 = std::move(lv1); // 合法, std::move可以将左值转移为右值
std::cout << rv1 << std::endl; // string,
const std::string& lv2 = lv1 + lv1; // 合法, 常量左值引用能够延长临时变量的申明周期
// lv2 += "Test"; // 非法, 引用的右值无法被修改
std::cout << lv2 << std::endl; // string,string
std::string&& rv2 = lv1 + lv2; // 合法, 右值引用延长临时对象声明周期
rv2 += "string"; // 合法, 非常量引用能够修改临时变量
std::cout << rv2 << std::endl; // string,string,string,
reference(rv2); // 输出左值
return 0;
}
| [
"ouchangkun@outlook.com"
] | ouchangkun@outlook.com |
d847df2098cb20a090b6632e791dcafe5b125434 | 0455ebc4ff111a7a7e67f06e5ab6afb83dc8618f | /monitor.cpp | 00c90ec4b53d7f3d8325835a37e225848742aae0 | [] | no_license | predbannikov/scaner | da7997a63665e6ed456975ec44081afeb645ba7e | 4a58beba9b8f6e26046cb04ec5a343779964fb04 | refs/heads/master | 2020-07-01T21:14:57.895875 | 2019-08-08T17:14:05 | 2019-08-08T17:14:05 | 201,303,114 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 5,093 | cpp | #include "monitor.h"
#include <QCoreApplication>
Monitor::Monitor(QObject *parent) : QObject(parent)
{
// while(doWork) {
// QFileInfo fileInfo("/proc/net/tcp");
// QEventLoop loop;
// QTimer timer;
// timer.setSingleShot(true);
// connect(&timer, &QTimer::timeout, &loop, &QEventLoop::quit);
// timer.start(10);
// loop.exec();
// }
}
void Monitor::loop()
{
QDir dir("/proc/");
QEventLoop loop;
QTimer timer;
connect(&timer, &QTimer::timeout, &loop, &QEventLoop::quit);
timer.start(10);
while(doWork) {
loop.exec();
QFile file("/proc/net/tcp");
if(!file.open(QFile::ReadOnly | QFile::Text)) {
qDebug() << "file not open to read";
}
QByteArray data = file.readAll();
file.close();
QList <QByteArray> arrayList = data.split('\n');
QStringList alllistnet;
// QHash<QString, QString> _hash;
dir.setFilter(QDir::Dirs | QDir::NoSymLinks | QDir::NoDotAndDotDot);
foreach(QString pid, dir.entryList()) {
QString path = "/proc/" + pid + "/fd/";
QDir dpid(path);
dpid.setFilter(QDir::NoDotAndDotDot);
QStringList list = dpid.entryList();
QString name = readNameProcess(pid);
if(name.contains(captureApp)) { // Ищем нашу цель - процесс в процессах
if(!pidsTarget.contains(pid)) {
pidsTarget << pid;
qDebug() << captureApp << "PID:" << pid << name;
}
}
foreach(QString str2, list) {
QFileInfo path2 = path + str2;
QString target = path2.symLinkTarget(); // Получаем полную ссылку на дескриптор Inode
if(target.contains("socket")) {
for(int i = 1; i < arrayList.size(); i++) { // Перебираем список /proc/net/tcp
QString withOutSpace = arrayList[i].simplified();
QStringList listData = withOutSpace.split(' ');
if(listData.size() < 10 )
continue;
if(listData[9] == "0")
continue;
if(target.contains(listData[9])) { // listData[9] - Inode , Каждый inode проверяем на соответствие с /proc/[PID]/fd/*
alllistnet << QString("%1|%2|%3|%4|%5").arg(listData[1]).arg(listData[2]).arg(pid).arg(listData[9]);
}
}
}
}
}
machDepend = alllistnet; // Совпадающие процессы с искомым Inode
}
}
QString Monitor::readNameProcess(QString pid) {
QFile file("/proc/" + pid + "/cmdline");
if(!file.exists())
return QString();
if(!file.open(QFile::ReadOnly | QFile::Text)) {
qDebug() << "not open read file";
return QString();
}
QString data = file.readAll();
file.close();
return data;
}
void Monitor::start()
{
// QString path("su user && wine /home/user/.wine/drive_c/ProgramFiles(x86)/Alawar/Веселаяферма.Новыеприключения/game_release.exe");
// QProcess process;
// process.setWorkingDirectory("/home/user/.wine/drive_c/ProgramFiles(x86)/Alawar/Веселаяферма.Новыеприключения/");
//// process.setProgram(path);
// qint64 *pid = nullptr;
// if(!process.startDetached(path)) {
// qDebug() << "no run program";
// }
qDebug() << "launch" ;
captureApp = "wine";
loop();
}
void Monitor::slotStop()
{
QString pathFile = QCoreApplication::applicationDirPath() + "/dump.log";
QDir(pathFile).remove(pathFile);
QFile file(pathFile);
doWork = false;
qDebug() << file;
if(!file.open(QFile::WriteOnly | QFile::Text | QFile::Append)) {
qDebug() << "not open file to write";
return;
}
for(int i = 0; i < dump.size(); i++)
file.write(dump[i]);
file.close();
}
void Monitor::test(QString port, QByteArray data, QStringList listParam)
{
port = port.toUpper();
// qDebug() << "test monitor" << str;
for(int i = 0; i < machDepend.size(); i++) {
if(machDepend[i].contains(port)) {
for(int k = 0; k < pidsTarget.size(); k++)
if(machDepend[i].contains(pidsTarget[k])) {
QString infoStr;
infoStr = QString("\n+---------------------------------src:%1\tdst:%2\tpsrc:%3\tdst:%4\tPID:%5\tpack%6\n|\n").arg(listParam[0]).arg(listParam[1]).arg(listParam[2]).arg(listParam[3]).arg(pidsTarget[k]).arg(listParam[4]);
dump.append(infoStr.toUtf8());
dump.append(data);
qDebug() << qPrintable(data);
return;
}
}
}
}
| [
"predbannikov.yurii@gmail.com"
] | predbannikov.yurii@gmail.com |
bb0348486220014ef49b0490bd998504af58205b | d39374332e76979bb3abd5cf59a9b112e98eb9c9 | /cuda/Camera.inl | 15c967170f972842171a5bec96cbf88b6083805d | [] | no_license | lateralpunk/rgrt | 6e1735a6c4cbb8eb661415f0d41a7d9cf4d07922 | 62b3ff791b9ad9f47ea72ac557b6013b8bf72e2b | refs/heads/master | 2021-01-10T19:09:43.697217 | 2019-01-11T17:14:53 | 2019-01-11T17:14:53 | 7,528,404 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,198 | inl | #pragma once
// ----------------------------------------------------------------- default constructor
Camera::Camera(void)
: eye(make_float3(0.0f, 0.0f, 500.0f)),
lookat(make_float3(0.0f)),
ra(0.0f),
up(make_float3(0.0f, 1.0f, 0.0f)),
u(make_float3(1.0f, 0.0f, 0.0f)),
v(make_float3(0.0f, 1.0f, 0.0f)),
w(make_float3(0.0f, 0.0f, 1.0f)),
d(500.0f),
zoom(1.0f)
{}
//-------------------------------------------------------------- compute_uvw
// This computes an orthornormal basis given the view point, lookat point, and up vector
void
Camera::compute_uvw(void) {
w = eye - lookat;
Maths::normalize_float3(w);
u = cross(up,w);
Maths::normalize_float3(u);
v = cross(w,u);
// take care of the singularity by hardwiring in specific camera orientations
if (eye.x == lookat.x && eye.z == lookat.z && eye.y > lookat.y) { // camera looking vertically down
u = make_float3(0.0f, 0.0f, 1.0f);
v = make_float3(1.0f, 0.0f, 0.0f);
w = make_float3(0.0f, 1.0f, 0.0f);
}
if (eye.x == lookat.x && eye.z == lookat.z && eye.y < lookat.y) { // camera looking vertically up
u = make_float3(1.0f, 0.0f, 0.0f);
v = make_float3(0.0f, 0.0f, 1.0f);
w = make_float3(0.0f, -1.0f, 0.0f);
}
}
// ----------------------------------------------------------------------------- get_direction
float3
Camera::get_direction(const float2 *p) const {
float3 dir = p->x * u + p->y * v - d * w;
Maths::normalize_float3(dir);
return(dir);
}
// ----------------------------------------------------------------------------- render_scene
// inlined access functions
// ----------------------------------------------------------------- set_eye
inline void
Camera::set_eye(const float3& p) {
eye = p;
}
// ----------------------------------------------------------------- set_eye
inline void
Camera::set_eye(const float x, const float y, const float z) {
eye.x = x; eye.y = y; eye.z = z;
}
// ----------------------------------------------------------------- set_lookat
inline void
Camera::set_lookat(const float3& p) {
lookat = p;
}
// ----------------------------------------------------------------- set_lookat
inline void
Camera::set_lookat(const float x, const float y, const float z) {
lookat.x = x; lookat.y = y; lookat.z = z;
}
// ----------------------------------------------------------------- set_up_vector
inline void
Camera::set_up_vector(const float3& u) {
up = u;
}
// ----------------------------------------------------------------- set_up_vector
inline void
Camera::set_up_vector(const float x, const float y, const float z) {
up.x = x; up.y = y; up.z = z;
}
// ----------------------------------------------------------------- set_roll
inline void
Camera::set_roll(const float r) {
ra = r;
}
//-------------------------------------------------------------------------- set_vpd
inline void
Camera::set_view_distance(float _d) {
d = _d;
}
//-------------------------------------------------------------------------- set_zoom
inline void
Camera::set_zoom(float zoom_factor) {
zoom = zoom_factor;
}
| [
"k5patel@me.com"
] | k5patel@me.com |
956a5ceaa15d4047d104e3949ba7bfea929840c1 | f7aa4d0585c124f2f33788a9ec131a0023f68036 | /benchmarks/threadResponseTime.cpp | 7159c36b6bb73738e3d2e6ea6a801bcb5226be6e | [
"MIT"
] | permissive | yumianhuli2/Physics3D | 51c643333c75dc4a5421d6ad22b1ae651c8519d9 | 30d3a2c926baf8b0f8503b0fb2d469bde65bfe83 | refs/heads/master | 2023-03-26T04:28:30.225829 | 2021-03-25T17:26:15 | 2021-03-25T17:26:15 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,073 | cpp | #include "benchmark.h"
#include <iostream>
#include <chrono>
#include <mutex>
#include <thread>
#include <vector>
#include "../physics/threading/threadPool.h"
using namespace std::chrono;
class ThreadCreateBenchmark : public Benchmark {
public:
ThreadCreateBenchmark() : Benchmark("threadCreateResponseTime") {}
virtual void init() override {}
virtual void run() override {
decltype(high_resolution_clock::now()) start;
std::mutex coutMutex;
std::cout << "\n";
auto work = [&start,&coutMutex]() {
auto response = high_resolution_clock::now();
nanoseconds delay = response - start;
coutMutex.lock();
std::cout << delay.count() / 1000 << " microseconds\n";
coutMutex.unlock();
std::this_thread::sleep_for(milliseconds(1000));
};
std::vector<std::thread> threads(std::thread::hardware_concurrency()-1);
for(int iter = 0; iter < 5; iter++) {
std::cout << "Run " << iter << "\n";
start = high_resolution_clock::now();
for(std::thread& t : threads) t = std::thread(work);
work();
for(std::thread& t : threads) t.join();
}
}
virtual void printResults(double timeTaken) override {}
} threadCreate;
class ThreadPoolBenchmark : public Benchmark {
public:
ThreadPoolBenchmark() : Benchmark("threadPoolResponseTime") {}
virtual void init() override {}
virtual void run() override {
decltype(high_resolution_clock::now()) start;
std::mutex coutMutex;
std::cout << "\n";
auto work = [&start, &coutMutex]() {
auto response = high_resolution_clock::now();
nanoseconds delay = response - start;
coutMutex.lock();
std::cout << delay.count() / 1000 << " microseconds\n";
coutMutex.unlock();
std::this_thread::sleep_for(milliseconds(1000));
};
std::vector<std::thread> threads(std::thread::hardware_concurrency() - 1);
ThreadPool threadPool;
for(int iter = 0; iter < 5; iter++) {
std::cout << "Run " << iter << "\n";
start = high_resolution_clock::now();
threadPool.doInParallel(work);
}
}
virtual void printResults(double timeTaken) override {}
} threadPool;
| [
"lennart.vanhirtum@gmail.com"
] | lennart.vanhirtum@gmail.com |
1ee4ed2dc22a3962d063938f2222bc6fa6b96378 | c81c93da5f45fe9ad41f098aff46a424b3a35ebe | /filesys.cpp | 70150db00707b19d337844c20a56870bc7f9bbd4 | [] | no_license | jorditorrentsguillen/WinUAE | adb1b3c068f7fb9c3f2522244d7cb86b022fab5b | a5f17c7727836a62742feab8f840c43beee49440 | refs/heads/master | 2021-01-15T20:47:44.496187 | 2015-08-12T17:21:24 | 2015-08-12T17:21:24 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 233,811 | cpp | /*
* UAE - The Un*x Amiga Emulator
*
* Unix file system handler for AmigaDOS
*
* Copyright 1996 Ed Hanway
* Copyright 1996, 1997 Bernd Schmidt
*
* Version 0.4: 970308
*
* Based on example code (c) 1988 The Software Distillery
* and published in Transactor for the Amiga, Volume 2, Issues 2-5.
* (May - August 1989)
*
* Known limitations:
* Does not support several (useless) 2.0+ packet types.
* May not return the correct error code in some cases.
* Does not check for sane values passed by AmigaDOS. May crash the emulation
* if passed garbage values.
* Could do tighter checks on malloc return values.
* Will probably fail spectacularly in some cases if the filesystem is
* modified at the same time by another process while UAE is running.
*/
#include "sysconfig.h"
#include "sysdeps.h"
#include "threaddep/thread.h"
#include "options.h"
#include "uae.h"
#include "memory.h"
#include "custom.h"
#include "events.h"
#include "newcpu.h"
#include "filesys.h"
#include "autoconf.h"
#include "traps.h"
#include "fsusage.h"
#include "native2amiga.h"
#include "scsidev.h"
#include "uaeserial.h"
#include "fsdb.h"
#include "zfile.h"
#include "zarchive.h"
#include "gui.h"
#include "gayle.h"
#include "idecontrollers.h"
#include "savestate.h"
#include "a2091.h"
#include "ncr_scsi.h"
#include "ncr9x_scsi.h"
#include "cdtv.h"
#include "sana2.h"
#include "bsdsocket.h"
#include "uaeresource.h"
#include "inputdevice.h"
#include "clipboard.h"
#include "consolehook.h"
#include "blkdev.h"
#include "isofs_api.h"
#include "scsi.h"
#include "uaenative.h"
#include "tabletlibrary.h"
#include "cpuboard.h"
#include "rommgr.h"
#ifdef RETROPLATFORM
#include "rp.h"
#endif
#define TRACING_ENABLED 1
int log_filesys = 0;
#if TRACING_ENABLED
#if 0
#define TRACE(x) if (log_filesys > 0 && (unit->volflags & MYVOLUMEINFO_CDFS)) { write_log x; }
#else
#define TRACE(x) if (log_filesys > 0) { write_log x; }
#endif
#define TRACEI(x) if (log_filesys > 0) { write_log x; }
#define TRACE2(x) if (log_filesys >= 2) { write_log x; }
#define TRACE3(x) if (log_filesys >= 3) { write_log x; }
#define DUMPLOCK(u,x) dumplock(u,x)
#else
#define TRACE(x)
#define DUMPLOCK(u,x)
#define TRACE2(x)
#define TRACE3(x)
#endif
#define UNIT_LED(unit) ((unit)->ui.unit_type == UNIT_CDFS ? LED_CD : LED_HD)
#define RTAREA_HEARTBEAT 0xFFFC
static uae_sem_t test_sem;
static int bootrom_header;
static uae_u32 dlg (uae_u32 a)
{
return (dbg (a + 0) << 24) | (dbg (a + 1) << 16) | (dbg (a + 2) << 8) | (dbg (a + 3) << 0);
}
static void aino_test (a_inode *aino)
{
#ifdef AINO_DEBUG
a_inode *aino2 = aino, *aino3;
for (;;) {
if (!aino || !aino->next)
return;
if ((aino->checksum1 ^ aino->checksum2) != 0xaaaa5555) {
write_log (_T("PANIC: corrupted or freed but used aino detected!"), aino);
}
aino3 = aino;
aino = aino->next;
if (aino->prev != aino3) {
write_log (_T("PANIC: corrupted aino linking!\n"));
break;
}
if (aino == aino2) break;
}
#endif
}
static void aino_test_init (a_inode *aino)
{
#ifdef AINO_DEBUG
aino->checksum1 = (uae_u32)aino;
aino->checksum2 = aino->checksum1 ^ 0xaaaa5555;
#endif
}
uaecptr filesys_initcode;
static uae_u32 fsdevname, fshandlername, filesys_configdev;
static uae_u32 cdfs_devname, cdfs_handlername;
static int filesys_in_interrupt;
static uae_u32 mountertask;
static int automountunit = -1;
static int autocreatedunit;
static int cd_unit_offset, cd_unit_number;
#define FS_STARTUP 0
#define FS_GO_DOWN 1
#define DEVNAMES_PER_HDF 32
#define UNIT_FILESYSTEM 0
#define UNIT_CDFS 1
typedef struct {
int unit_type;
int open; // >0 start as filesystem, <0 = allocated but do not start
TCHAR *devname; /* device name, e.g. UAE0: */
uaecptr devname_amiga;
uaecptr startup;
uaecptr devicenode;
TCHAR *volname; /* volume name, e.g. CDROM, WORK, etc. */
int volflags; /* volume flags, readonly, stream uaefsdb support */
TCHAR *rootdir; /* root native directory/hdf. empty drive if invalid path */
struct zvolume *zarchive;
TCHAR *rootdirdiff; /* "diff" file/directory */
bool readonly; /* disallow write access? */
bool locked; /* action write protect */
bool unknown_media; /* ID_UNREADABLE_DISK */
int bootpri; /* boot priority. -128 = no autoboot, -129 = no mount */
int devno;
int controller_type;
int controller_unit;
bool wasisempty; /* if true, this unit was created empty */
bool canremove; /* if true, this unit can be safely ejected and remounted */
bool configureddrive; /* if true, this is drive that was manually configured */
bool inject_icons; /* inject icons if directory filesystem */
struct hardfiledata hf;
/* Threading stuff */
smp_comm_pipe *volatile unit_pipe, *volatile back_pipe;
uae_thread_id tid;
struct _unit *self;
/* Reset handling */
uae_sem_t reset_sync_sem;
volatile int reset_state;
/* RDB stuff */
uaecptr rdb_devname_amiga[DEVNAMES_PER_HDF];
int rdb_lowcyl;
int rdb_highcyl;
int rdb_cylblocks;
uae_u8 *rdb_filesysstore;
int rdb_filesyssize;
TCHAR *filesysdir;
/* filesystem seglist */
uaecptr filesysseg;
uae_u32 rdb_dostype;
/* CDFS */
bool cd_open;
int cddevno;
void *cdfs_superblock;
} UnitInfo;
struct uaedev_mount_info {
UnitInfo ui[MAX_FILESYSTEM_UNITS];
};
static struct uaedev_mount_info mountinfo;
int nr_units (void)
{
int i, cnt = 0;
for (i = 0; i < MAX_FILESYSTEM_UNITS; i++) {
if (mountinfo.ui[i].open > 0)
cnt++;
}
return cnt;
}
int nr_directory_units (struct uae_prefs *p)
{
int i, cnt = 0;
if (p) {
for (i = 0; i < p->mountitems; i++) {
if (p->mountconfig[i].ci.controller_type == HD_CONTROLLER_TYPE_UAE)
cnt++;
}
} else {
for (i = 0; i < MAX_FILESYSTEM_UNITS; i++) {
if (mountinfo.ui[i].open > 0 && mountinfo.ui[i].controller_type == HD_CONTROLLER_TYPE_UAE)
cnt++;
}
}
return cnt;
}
static int is_virtual (int unit_no)
{
int t = is_hardfile (unit_no);
return t == FILESYS_VIRTUAL || t == FILESYS_CD;
}
int is_hardfile (int unit_no)
{
if (mountinfo.ui[unit_no].volname || mountinfo.ui[unit_no].wasisempty || mountinfo.ui[unit_no].unknown_media) {
if (unit_no >= cd_unit_offset && unit_no < cd_unit_offset + cd_unit_number)
return FILESYS_CD;
return FILESYS_VIRTUAL;
}
if (mountinfo.ui[unit_no].hf.ci.sectors == 0) {
if (mountinfo.ui[unit_no].hf.flags & 1)
return FILESYS_HARDDRIVE;
return FILESYS_HARDFILE_RDB;
}
return FILESYS_HARDFILE;
}
static void close_filesys_unit (UnitInfo *uip)
{
if (!uip->open)
return;
if (uip->hf.handle_valid)
hdf_close (&uip->hf);
if (uip->volname != 0)
xfree (uip->volname);
if (uip->devname != 0)
xfree (uip->devname);
if (uip->rootdir != 0)
xfree (uip->rootdir);
if (uip->unit_pipe)
xfree (uip->unit_pipe);
if (uip->back_pipe)
xfree (uip->back_pipe);
if (uip->cd_open) {
sys_command_close (uip->cddevno);
isofs_unmount (uip->cdfs_superblock);
}
uip->unit_pipe = 0;
uip->back_pipe = 0;
uip->hf.handle_valid = 0;
uip->volname = 0;
uip->devname = 0;
uip->rootdir = 0;
uip->open = 0;
uip->cd_open = 0;
}
static uaedev_config_data *getuci (struct uaedev_config_data *uci, int nr)
{
return &uci[nr];
}
static UnitInfo *getuip (struct uae_prefs *p, int index)
{
if (index < 0)
return NULL;
index = p->mountconfig[index].configoffset;
if (index < 0)
return NULL;
return &mountinfo.ui[index];
}
static int getuindex (struct uae_prefs *p, int index)
{
if (index < 0)
return -1;
return p->mountconfig[index].unitnum;
}
int get_filesys_unitconfig (struct uae_prefs *p, int index, struct mountedinfo *mi)
{
UnitInfo *ui = getuip (p, index);
struct uaedev_config_data *uci = &p->mountconfig[index];
UnitInfo uitmp;
memset (mi, 0, sizeof (struct mountedinfo));
memset (&uitmp, 0, sizeof uitmp);
_tcscpy (mi->rootdir, uci->ci.rootdir);
if (!ui) {
ui = &uitmp;
if (uci->ci.type == UAEDEV_DIR) {
mi->ismounted = 1;
if (uci->ci.rootdir && _tcslen (uci->ci.rootdir) == 0)
return FILESYS_VIRTUAL;
if (my_existsfile (uci->ci.rootdir)) {
mi->ismedia = 1;
return FILESYS_VIRTUAL;
}
if (my_getvolumeinfo (uci->ci.rootdir) < 0)
return -1;
mi->ismedia = true;
return FILESYS_VIRTUAL;
} else if (uci->ci.type == UAEDEV_HDF) {
ui->hf.ci.readonly = true;
ui->hf.ci.blocksize = uci->ci.blocksize;
int err = hdf_open (&ui->hf, uci->ci.rootdir);
if (err <= 0) {
mi->ismedia = false;
mi->ismounted = true;
mi->error = err;
if (uci->ci.reserved == 0 && uci->ci.sectors == 0 && uci->ci.surfaces == 0) {
if (ui->hf.flags & 1)
return FILESYS_HARDDRIVE;
return FILESYS_HARDFILE_RDB;
}
return -1;
}
mi->ismedia = true;
if (ui->hf.drive_empty)
mi->ismedia = 0;
hdf_close (&ui->hf);
} else if (uci->ci.type == UAEDEV_CD) {
struct device_info di;
ui->hf.ci.readonly = true;
ui->hf.ci.blocksize = uci->ci.blocksize;
mi->size = -1;
mi->ismounted = true;
if (blkdev_get_info (p, ui->hf.ci.device_emu_unit, &di)) {
mi->ismedia = di.media_inserted != 0;
_tcscpy (mi->rootdir, di.label);
}
#if 0
if (ui->hf.ci.cd_emu_unit == 0)
_tcscpy (mi->rootdir, _T("CD"));
else
_stprintf (mi->rootdir, _T("CD %d"), ui->hf.ci.cd_emu_unit);
#endif
}
} else if (uci->ci.type != UAEDEV_TAPE) {
if (ui->controller_type == HD_CONTROLLER_TYPE_UAE) { // what is this? || (ui->controller && p->cs_ide)) {
mi->ismounted = 1;
if (uci->ci.type == UAEDEV_HDF)
mi->ismedia = ui->hf.drive_empty ? false : true;
else
mi->ismedia = true;
}
}
if (uci->ci.type == UAEDEV_TAPE) {
struct device_info di;
int unitnum = getuindex (p, index);
mi->size = -1;
mi->ismounted = false;
if (unitnum >= 0) {
mi->ismounted = true;
if (tape_get_info (unitnum, &di)) {
mi->ismedia = di.media_inserted != 0;
_tcscpy (mi->rootdir, di.label);
}
} else {
struct scsi_data_tape *tape;
unitnum = 0;
tape = tape_alloc (unitnum, uci->ci.rootdir, uci->ci.readonly);
if (tape) {
if (tape_get_info (unitnum, &di)) {
mi->ismedia = di.media_inserted != 0;
_tcscpy (mi->rootdir, di.label);
}
tape_free (tape);
}
}
return FILESYS_TAPE;
}
if (mi->size < 0)
return -1;
mi->size = ui->hf.virtsize;
if (uci->ci.highcyl) {
uci->ci.cyls = mi->nrcyls = uci->ci.highcyl;
} else {
uci->ci.cyls = mi->nrcyls = (int)(uci->ci.sectors * uci->ci.surfaces ? (ui->hf.virtsize / uci->ci.blocksize) / (uci->ci.sectors * uci->ci.surfaces) : 0);
}
if (uci->ci.type == UAEDEV_DIR)
return FILESYS_VIRTUAL;
if (uci->ci.reserved == 0 && uci->ci.sectors == 0 && uci->ci.surfaces == 0) {
if (ui->hf.flags & 1)
return FILESYS_HARDDRIVE;
return FILESYS_HARDFILE_RDB;
}
return FILESYS_HARDFILE;
}
static void stripsemicolon (TCHAR *s)
{
if (!s)
return;
while (_tcslen(s) > 0 && s[_tcslen(s) - 1] == ':')
s[_tcslen(s) - 1] = 0;
}
static void stripspace (TCHAR *s)
{
int i;
if (!s)
return;
for (i = 0; i < _tcslen (s); i++) {
if (s[i] == ' ')
s[i] = '_';
}
}
static void striplength (TCHAR *s, int len)
{
if (!s)
return;
if (_tcslen (s) <= len)
return;
s[len] = 0;
}
static void fixcharset (TCHAR *s)
{
char tmp[MAX_DPATH];
if (!s)
return;
ua_fs_copy (tmp, MAX_DPATH, s, '_');
au_fs_copy (s, strlen (tmp) + 1, tmp);
}
TCHAR *validatevolumename (TCHAR *s, const TCHAR *def)
{
stripsemicolon (s);
fixcharset (s);
striplength (s, 30);
if (_tcslen(s) == 0 && def) {
xfree(s);
s = my_strdup(def);
}
return s;
}
TCHAR *validatedevicename (TCHAR *s, const TCHAR *def)
{
stripsemicolon (s);
stripspace (s);
fixcharset (s);
striplength (s, 30);
if (_tcslen(s) == 0 && def) {
xfree(s);
s = my_strdup(def);
}
return s;
}
TCHAR *filesys_createvolname (const TCHAR *volname, const TCHAR *rootdir, struct zvolume *zv, const TCHAR *def)
{
TCHAR *nvol = NULL;
int i, archivehd;
TCHAR *p = NULL;
archivehd = -1;
if (my_existsfile (rootdir))
archivehd = 1;
else if (my_existsdir (rootdir))
archivehd = 0;
if (zv && zv->volumename && _tcslen(zv->volumename) > 0) {
nvol = my_strdup(zv->volumename);
nvol = validatevolumename (nvol, def);
return nvol;
}
if ((!volname || _tcslen (volname) == 0) && rootdir && archivehd >= 0) {
p = my_strdup (rootdir);
for (i = _tcslen (p) - 1; i >= 0; i--) {
TCHAR c = p[i];
if (c == ':' || c == '/' || c == '\\') {
if (i == _tcslen (p) - 1)
continue;
if (!_tcscmp (p + i, _T(":\\"))) {
xfree (p);
p = xmalloc (TCHAR, 10);
p[0] = rootdir[0];
p[1] = 0;
i = 0;
} else {
i++;
}
break;
}
}
if (i >= 0)
nvol = my_strdup (p + i);
}
if (!nvol && archivehd >= 0) {
TCHAR *s = NULL;
if (volname && _tcslen (volname) > 0)
nvol = my_strdup (volname);
else
nvol = my_strdup (def);
}
if (!nvol) {
if (volname && _tcslen (volname))
nvol = my_strdup (volname);
else
nvol = my_strdup (_T(""));
}
nvol = validatevolumename (nvol, def);
xfree (p);
return nvol;
}
static int set_filesys_volume (const TCHAR *rootdir, int *flags, bool *readonly, bool *emptydrive, struct zvolume **zvp)
{
*emptydrive = 0;
if (my_existsfile (rootdir)) {
struct zvolume *zv;
zv = zfile_fopen_archive (rootdir);
if (!zv) {
error_log (_T("'%s' is not a supported archive file."), rootdir);
return -1;
}
*zvp = zv;
*flags = MYVOLUMEINFO_ARCHIVE;
*readonly = 1;
} else {
*flags = my_getvolumeinfo (rootdir);
if (*flags < 0) {
if (rootdir && rootdir[0])
error_log (_T("directory '%s' not found, mounting as empty drive."), rootdir);
*emptydrive = 1;
*flags = 0;
} else if ((*flags) & MYVOLUMEINFO_READONLY) {
error_log (_T("'%s' set to read-only."), rootdir);
*readonly = 1;
}
}
return 1;
}
void uci_set_defaults (struct uaedev_config_info *uci, bool rdb)
{
memset (uci, 0, sizeof (struct uaedev_config_info));
if (!rdb) {
uci->sectors = 32;
uci->reserved = 2;
uci->surfaces = 1;
}
uci->blocksize = 512;
uci->maxtransfer = 0x7fffffff;
uci->mask = 0xffffffff;
uci->bufmemtype = 1;
uci->buffers = 50;
uci->stacksize = 4000;
uci->priority = -129;
uci->sectorsperblock = 1;
uci->device_emu_unit = -1;
}
static int set_filesys_unit_1 (int nr, struct uaedev_config_info *ci)
{
UnitInfo *ui;
int i;
bool emptydrive = false;
bool iscd;
struct uaedev_config_info c;
memcpy (&c, ci, sizeof (struct uaedev_config_info));
if (nr < 0) {
for (nr = 0; nr < MAX_FILESYSTEM_UNITS; nr++) {
if (!mountinfo.ui[nr].open)
break;
}
if (nr == MAX_FILESYSTEM_UNITS) {
error_log (_T("No slot allocated for this unit"));
return -1;
}
}
if (ci->controller_type != HD_CONTROLLER_TYPE_UAE || ci->type == UAEDEV_TAPE) {
ui = &mountinfo.ui[nr];
memset (ui, 0, sizeof (UnitInfo));
memcpy (&ui->hf.ci, &c, sizeof (struct uaedev_config_info));
ui->readonly = c.readonly;
ui->unit_type = -1;
ui->open = -1;
return nr;
}
my_resolvesoftlink (c.rootdir, MAX_DPATH);
iscd = nr >= cd_unit_offset && nr < cd_unit_offset + cd_unit_number;
for (i = 0; i < MAX_FILESYSTEM_UNITS; i++) {
if (nr == i || !mountinfo.ui[i].open || mountinfo.ui[i].rootdir == NULL || is_hardfile (i) == FILESYS_CD)
continue;
if (_tcslen (c.rootdir) > 0 && !_tcsicmp (mountinfo.ui[i].rootdir, c.rootdir)) {
error_log (_T("directory/hardfile '%s' already added."), c.rootdir);
return -1;
}
}
ui = &mountinfo.ui[nr];
memset (ui, 0, sizeof (UnitInfo));
if (iscd) {
ui->unit_type = UNIT_CDFS;
emptydrive = 1;
ui->volflags = MYVOLUMEINFO_CDFS | MYVOLUMEINFO_READONLY;
c.readonly = true;
} else if (c.volname[0]) {
int flags = 0;
emptydrive = 1;
if (c.rootdir[0]) {
if (set_filesys_volume (c.rootdir, &flags, &c.readonly, &emptydrive, &ui->zarchive) < 0)
return -1;
}
ui->volname = filesys_createvolname (c.volname, c.rootdir, ui->zarchive, _T("harddrive"));
ui->volflags = flags;
} else {
ui->unit_type = UNIT_FILESYSTEM;
memcpy (&ui->hf.ci, &c, sizeof (struct uaedev_config_info));
ui->hf.unitnum = nr;
ui->volname = 0;
if (ui->hf.ci.rootdir[0]) {
if (hdf_open (&ui->hf) <= 0 && !c.readonly) {
write_log (_T("Attempting to open '%s' in read-only mode.\n"), ui->hf.ci.rootdir);
ui->hf.ci.readonly = c.readonly = true;
if (hdf_open (&ui->hf) > 0) {
error_log (_T("'%s' opened in read-only mode.\n"), ui->hf.ci.rootdir);
}
}
} else {
// empty drive?
ui->hf.drive_empty = 1;
}
if (!ui->hf.drive_empty) {
if (ui->hf.handle_valid == 0) {
error_log (_T("Hardfile '%s' not found."), ui->hf.ci.rootdir);
goto err;
}
if (ui->hf.ci.blocksize > ui->hf.virtsize || ui->hf.virtsize == 0) {
error_log (_T("Hardfile '%s' too small."), ui->hf.ci.rootdir);
goto err;
}
}
if ((ui->hf.ci.blocksize & (ui->hf.ci.blocksize - 1)) != 0 || ui->hf.ci.blocksize == 0) {
error_log (_T("Hardfile '%s' bad blocksize %d."), ui->hf.ci.rootdir, ui->hf.ci.blocksize);
goto err;
}
if ((ui->hf.ci.sectors || ui->hf.ci.surfaces || ui->hf.ci.reserved) &&
(ui->hf.ci.sectors < 1 || ui->hf.ci.surfaces < 1 || ui->hf.ci.surfaces > 1023 ||
ui->hf.ci.reserved < 0 || ui->hf.ci.reserved > 1023) != 0) {
error_log (_T("Hardfile '%s' bad hardfile geometry."), ui->hf.ci.rootdir);
goto err;
}
if (!ui->hf.ci.highcyl) {
ui->hf.ci.cyls = (int)(ui->hf.ci.sectors * ui->hf.ci.surfaces ? (ui->hf.virtsize / ui->hf.ci.blocksize) / (ui->hf.ci.sectors * ui->hf.ci.surfaces) : 0);
}
if (!ui->hf.ci.cyls)
ui->hf.ci.cyls = ui->hf.ci.highcyl;
if (!ui->hf.ci.cyls)
ui->hf.ci.cyls = 1;
}
ui->self = 0;
ui->reset_state = FS_STARTUP;
ui->wasisempty = emptydrive;
ui->canremove = emptydrive && (ci->flags & MYVOLUMEINFO_REUSABLE);
ui->rootdir = my_strdup (c.rootdir);
ui->devname = my_strdup (c.devname);
stripsemicolon(ui->devname);
if (c.filesys[0])
ui->filesysdir = my_strdup (c.filesys);
ui->readonly = c.readonly;
if (c.bootpri < -129)
c.bootpri = -129;
if (c.bootpri > 127)
c.bootpri = 127;
ui->bootpri = c.bootpri;
ui->inject_icons = c.inject_icons;
ui->open = 1;
return nr;
err:
if (ui->hf.handle_valid)
hdf_close (&ui->hf);
return -1;
}
static int set_filesys_unit (int nr, struct uaedev_config_info *ci)
{
int ret;
ret = set_filesys_unit_1 (nr, ci);
return ret;
}
static int add_filesys_unit (struct uaedev_config_info *ci)
{
int ret;
if (nr_units () >= MAX_FILESYSTEM_UNITS)
return -1;
ret = set_filesys_unit_1 (-1, ci);
#ifdef RETROPLATFORM
if (ret >= 0) {
rp_hd_device_enable (ret, true);
rp_harddrive_image_change (ret, ci->readonly, ci->rootdir);
}
#endif
return ret;
}
int kill_filesys_unitconfig (struct uae_prefs *p, int nr)
{
struct uaedev_config_data *uci;
if (nr < 0)
return 0;
uci = getuci (p->mountconfig, nr);
hardfile_do_disk_change (uci, 0);
if (uci->configoffset >= 0 && uci->ci.controller_type == HD_CONTROLLER_TYPE_UAE)
filesys_media_change (uci->ci.rootdir, 0, uci);
while (nr < MOUNT_CONFIG_SIZE) {
memmove (&p->mountconfig[nr], &p->mountconfig[nr + 1], sizeof (struct uaedev_config_data));
nr++;
}
p->mountitems--;
memset (&p->mountconfig[MOUNT_CONFIG_SIZE - 1], 0, sizeof (struct uaedev_config_data));
return 1;
}
int move_filesys_unitconfig (struct uae_prefs *p, int nr, int to)
{
struct uaedev_config_data *uci1, *uci2, tmpuci;
uci1 = getuci (p->mountconfig, nr);
uci2 = getuci (p->mountconfig, to);
if (nr == to)
return 0;
memcpy (&tmpuci, uci1, sizeof (struct uaedev_config_data));
memcpy (uci1, uci2, sizeof (struct uaedev_config_data));
memcpy (uci2, &tmpuci, sizeof (struct uaedev_config_data));
return 1;
}
void filesys_addexternals (void);
static void allocuci (struct uae_prefs *p, int nr, int idx, int unitnum)
{
struct uaedev_config_data *uci = &p->mountconfig[nr];
if (idx >= 0) {
UnitInfo *ui;
uci->configoffset = idx;
ui = &mountinfo.ui[idx];
ui->configureddrive = 1;
uci->unitnum = unitnum;
} else {
uci->configoffset = -1;
uci->unitnum = -1;
}
}
static void allocuci (struct uae_prefs *p, int nr, int idx)
{
allocuci (p, nr, idx, -1);
}
static const TCHAR *getunittype(struct uaedev_config_info *uci)
{
return uci->type == UAEDEV_CD ? _T("CD") : (uci->type == UAEDEV_TAPE ? _T("TAPE") : _T("HD"));
}
static int cpuboard_hd;
static romconfig cpuboard_dummy;
void add_cpuboard_unit(int unit, struct uaedev_config_info *uci, struct romconfig *rc)
{
int flags = (uci->controller_type >= HD_CONTROLLER_TYPE_IDE_FIRST && uci->controller_type <= HD_CONTROLLER_TYPE_IDE_LAST) ? EXPANSIONTYPE_IDE : EXPANSIONTYPE_SCSI;
const struct cpuboardtype *cbt = &cpuboards[currprefs.cpuboard_type];
cpuboard_hd = 0;
if (cbt->subtypes) {
if (cbt->subtypes[currprefs.cpuboard_subtype].add && (cbt->subtypes[currprefs.cpuboard_subtype].deviceflags & flags)) {
if (unit >= 0) {
write_log(_T("Adding CPUBoard '%s' %s unit %d ('%s')\n"),
cbt->subtypes[currprefs.cpuboard_subtype].name,
getunittype(uci), unit, uci->rootdir);
}
cbt->subtypes[currprefs.cpuboard_subtype].add(unit, uci, rc);
cpuboard_hd = 1;
}
}
}
static void add_cpuboard_unit_init(void)
{
memset(&cpuboard_dummy, 0, sizeof cpuboard_dummy);
cpuboard_dummy.device_id = 7;
if (currprefs.cpuboard_type) {
struct romconfig *rc = get_device_romconfig(&currprefs, ROMTYPE_CPUBOARD, 0);
if (!rc)
rc = &cpuboard_dummy;
const struct cpuboardtype *cbt = &cpuboards[currprefs.cpuboard_type];
if (cbt->subtypes) {
if (cbt->subtypes[currprefs.cpuboard_subtype].add) {
const struct cpuboardsubtype *cst = &cbt->subtypes[currprefs.cpuboard_subtype];
struct uaedev_config_info ci = { 0 };
write_log(_T("Initializing CPUBoard '%s' %s controller\n"),
cst->name, (cst->deviceflags & EXPANSIONTYPE_SCSI) ? _T("SCSI") : _T("IDE"));
cst->add(-1, &ci, rc);
}
}
}
}
static bool ismainboardide(void)
{
return currprefs.cs_ide != 0;
}
static bool isa3000scsi(void)
{
return currprefs.cs_mbdmac == 1;
}
static bool isa4000tscsi(void)
{
return currprefs.cs_mbdmac == 2;
}
static bool iscdtvscsi(void)
{
return currprefs.cs_cdtvscsi != 0;
}
// this needs better implementation.
static void add_mainboard_unit_init(void)
{
if (ismainboardide()) {
write_log(_T("Initializing mainboard IDE\n"));
gayle_add_ide_unit(-1, NULL);
}
if (isa3000scsi()) {
write_log(_T("Initializing A3000 mainboard SCSI\n"));
a3000_add_scsi_unit(-1, NULL, NULL);
}
if (isa4000tscsi()) {
write_log(_T("Initializing A4000T mainboard SCSI\n"));
a4000t_add_scsi_unit(-1, NULL, NULL);
}
if (iscdtvscsi()) {
write_log(_T("Initializing CDTV SCSI expansion\n"));
cdtv_add_scsi_unit(-1, NULL, NULL);
}
}
static bool add_ide_unit(int type, int unit, struct uaedev_config_info *uci)
{
bool added = false;
if (type == HD_CONTROLLER_TYPE_IDE_MB) {
if (ismainboardide()) {
write_log(_T("Adding mainboard IDE %s unit %d ('%s')\n"),
getunittype(uci), unit, uci->rootdir);
gayle_add_ide_unit(unit, uci);
added = true;
}
} else if (type >= HD_CONTROLLER_TYPE_IDE_EXPANSION_FIRST && type <= HD_CONTROLLER_TYPE_IDE_LAST) {
for (int i = 0; expansionroms[i].name; i++) {
if (i == type - HD_CONTROLLER_TYPE_IDE_EXPANSION_FIRST) {
const struct expansionromtype *ert = &expansionroms[i];
if ((ert->deviceflags & 2) && cfgfile_board_enabled(&currprefs, ert->romtype, uci->controller_type_unit)) {
cpuboard_hd = 1;
if (ert->add) {
struct romconfig *rc = get_device_romconfig(&currprefs, ert->romtype, uci->controller_type_unit);
write_log(_T("Adding IDE %s '%s' unit %d ('%s')\n"), getunittype(uci),
ert->name, unit, uci->rootdir);
ert->add(unit, uci, rc);
}
if (cpuboard_hd)
added = true;
}
}
}
}
return added;
}
static bool add_scsi_unit(int type, int unit, struct uaedev_config_info *uci)
{
bool added = false;
if (type == HD_CONTROLLER_TYPE_SCSI_A3000) {
#ifdef A2091
if (isa3000scsi()) {
write_log(_T("Adding A3000 mainboard SCSI %s unit %d ('%s')\n"), getunittype(uci),
unit, uci->rootdir);
a3000_add_scsi_unit (unit, uci, NULL);
added = true;
}
#endif
} else if (type == HD_CONTROLLER_TYPE_SCSI_A4000T) {
#ifdef NCR
if (isa4000tscsi()) {
write_log(_T("Adding A4000T mainboard SCSI %s unit %d ('%s')\n"), getunittype(uci),
unit, uci->rootdir);
a4000t_add_scsi_unit (unit, uci, NULL);
added = true;
}
#endif
} else if (type == HD_CONTROLLER_TYPE_SCSI_CDTV) {
#ifdef CDTV
if (iscdtvscsi()) {
write_log(_T("Adding CDTV SCSI expansion %s unit %d ('%s')\n"), getunittype(uci),
unit, uci->rootdir);
cdtv_add_scsi_unit (unit, uci, NULL);
added = true;
}
#endif
} else if (type >= HD_CONTROLLER_TYPE_SCSI_EXPANSION_FIRST && type <= HD_CONTROLLER_TYPE_SCSI_LAST) {
for (int i = 0; expansionroms[i].name; i++) {
if (i == type - HD_CONTROLLER_TYPE_SCSI_EXPANSION_FIRST) {
const struct expansionromtype *ert = &expansionroms[i];
if ((ert->deviceflags & 1) && cfgfile_board_enabled(&currprefs, ert->romtype, uci->controller_type_unit)) {
cpuboard_hd = 1;
if (ert->add) {
struct romconfig *rc = get_device_romconfig(&currprefs, ert->romtype, uci->controller_type_unit);
write_log(_T("Adding SCSI %s '%s' unit %d ('%s')\n"), getunittype(uci),
ert->name, unit, uci->rootdir);
ert->add(unit, uci, rc);
}
if (cpuboard_hd)
added = true;
}
}
}
}
return added;
}
static void initialize_mountinfo (void)
{
int nr;
UnitInfo *uip = &mountinfo.ui[0];
cd_unit_offset = MAX_FILESYSTEM_UNITS;
autocreatedunit = 0;
for (nr = 0; nr < currprefs.mountitems; nr++) {
struct uaedev_config_data *uci = &currprefs.mountconfig[nr];
if (uci->ci.controller_type == HD_CONTROLLER_TYPE_UAE && (uci->ci.type == UAEDEV_DIR || uci->ci.type == UAEDEV_HDF)) {
struct uaedev_config_info ci;
memcpy (&ci, &uci->ci, sizeof (struct uaedev_config_info));
ci.flags = MYVOLUMEINFO_REUSABLE;
int idx = set_filesys_unit_1 (-1, &ci);
allocuci (&currprefs, nr, idx);
}
}
filesys_addexternals ();
nr = nr_units ();
cd_unit_offset = nr;
cd_unit_number = 0;
if (currprefs.scsi && currprefs.win32_automount_cddrives) {
uae_u32 mask = scsi_get_cd_drive_mask ();
for (int i = 0; i < 32; i++) {
if (mask & (1 << i)) {
struct uaedev_config_info ci = { 0 };
_stprintf (ci.devname, _T("CD%d"), i);
cd_unit_number++;
_tcscpy (ci.rootdir, _T("/"));
ci.readonly = true;
ci.sectors = 1;
ci.surfaces = 1;
ci.blocksize = 2048;
int idx = set_filesys_unit_1 (i + cd_unit_offset, &ci);
allocuci (&currprefs, nr, idx);
nr++;
}
}
}
for (nr = 0; nr < currprefs.mountitems; nr++) {
struct uaedev_config_data *uci = &currprefs.mountconfig[nr];
if (uci->ci.controller_type == HD_CONTROLLER_TYPE_UAE) {
if (uci->ci.type == UAEDEV_TAPE) {
struct uaedev_config_info ci;
memcpy (&ci, &uci->ci, sizeof (struct uaedev_config_info));
int unitnum = scsi_add_tape (&uci->ci);
if (unitnum >= 0) {
int idx = set_filesys_unit_1 (-1, &ci);
allocuci (&currprefs, nr, idx, unitnum);
}
}
}
}
// init all controllers first
add_mainboard_unit_init();
add_cpuboard_unit_init();
for (int i = 0; expansionroms[i].name; i++) {
const struct expansionromtype *ert = &expansionroms[i];
for (int j = 0; j < MAX_DUPLICATE_EXPANSION_BOARDS; j++) {
struct romconfig *rc = get_device_romconfig(&currprefs, ert->romtype, j);
if ((ert->deviceflags & 3) && rc) {
if (ert->add) {
struct uaedev_config_info ci = { 0 };
ci.controller_type_unit = j;
ert->add(-1, &ci, rc);
}
}
}
}
for (nr = 0; nr < currprefs.mountitems; nr++) {
struct uaedev_config_info *uci = &currprefs.mountconfig[nr].ci;
int type = uci->controller_type;
int unit = uci->controller_unit;
bool added = false;
if (type == HD_CONTROLLER_TYPE_UAE) {
continue;
} else if (type != HD_CONTROLLER_TYPE_IDE_AUTO && type >= HD_CONTROLLER_TYPE_IDE_FIRST && type <= HD_CONTROLLER_TYPE_IDE_LAST) {
added = add_ide_unit(type, unit, uci);
} else if (type == HD_CONTROLLER_TYPE_IDE_AUTO) {
for (int st = HD_CONTROLLER_TYPE_IDE_FIRST; st <= HD_CONTROLLER_TYPE_IDE_LAST; st++) {
added = add_ide_unit(st, unit, uci);
if (added)
break;
}
} else if (type != HD_CONTROLLER_TYPE_SCSI_AUTO && type >= HD_CONTROLLER_TYPE_SCSI_FIRST && type <= HD_CONTROLLER_TYPE_SCSI_LAST) {
added = add_scsi_unit(type, unit, uci);
} else if (type == HD_CONTROLLER_TYPE_SCSI_AUTO) {
for (int st = HD_CONTROLLER_TYPE_SCSI_FIRST; st <= HD_CONTROLLER_TYPE_SCSI_LAST; st++) {
added = add_scsi_unit(st, unit, uci);
if (added)
break;
}
} else if (type == HD_CONTROLLER_TYPE_PCMCIA_SRAM) {
gayle_add_pcmcia_sram_unit (uci);
added = true;
} else if (type == HD_CONTROLLER_TYPE_PCMCIA_IDE) {
gayle_add_pcmcia_ide_unit (uci);
added = true;
}
if (added)
allocuci (&currprefs, nr, -1);
}
}
int sprintf_filesys_unit (TCHAR *buffer, int num)
{
UnitInfo *uip = mountinfo.ui;
if (uip[num].volname != 0)
_stprintf (buffer, _T("(DH%d:) Filesystem, %s: %s %s"), num, uip[num].volname,
uip[num].rootdir, uip[num].readonly ? "ro" : "");
else
_stprintf (buffer, _T("(DH%d:) Hardfile, \"%s\", size %d Mbytes"), num,
uip[num].rootdir, (int)(uip[num].hf.virtsize / (1024 * 1024)));
return 0;
}
static void free_mountinfo (void)
{
int i;
for (i = 0; i < MAX_FILESYSTEM_UNITS; i++)
close_filesys_unit (mountinfo.ui + i);
gayle_free_units ();
}
struct hardfiledata *get_hardfile_data (int nr)
{
UnitInfo *uip = mountinfo.ui;
if (nr < 0 || nr >= MAX_FILESYSTEM_UNITS || uip[nr].open == 0 || is_virtual (nr))
return 0;
return &uip[nr].hf;
}
/* minimal AmigaDOS definitions */
/* field offsets in DosPacket */
#define dp_Type 8
#define dp_Res1 12
#define dp_Res2 16
#define dp_Arg1 20
#define dp_Arg2 24
#define dp_Arg3 28
#define dp_Arg4 32
#define dp_Arg5 36
#define DP64_INIT -3L
#define dp64_Type 8
#define dp64_Res0 12
#define dp64_Res2 16
#define dp64_Res1 24
#define dp64_Arg1 32
#define dp64_Arg2 40
#define dp64_Arg3 48
#define dp64_Arg4 52
#define dp64_Arg5 56
/* result codes */
#define DOS_TRUE ((uae_u32)-1L)
#define DOS_FALSE (0L)
/* DirEntryTypes */
#define ST_PIPEFILE -5
#define ST_LINKFILE -4
#define ST_FILE -3
#define ST_ROOT 1
#define ST_USERDIR 2
#define ST_SOFTLINK 3
#define ST_LINKDIR 4
#if 1
#define MAXFILESIZE32 (0xffffffff)
#else
/* technically correct but most native
* filesystems don't enforce it
*/
#define MAXFILESIZE32 (0x7fffffff)
#endif
#define MAXFILESIZE32_2G (0x7fffffff)
/* Passed as type to Lock() */
#define SHARED_LOCK -2 /* File is readable by others */
#define ACCESS_READ -2 /* Synonym */
#define EXCLUSIVE_LOCK -1 /* No other access allowed */
#define ACCESS_WRITE -1 /* Synonym */
/* packet types */
#define ACTION_CURRENT_VOLUME 7
#define ACTION_LOCATE_OBJECT 8
#define ACTION_RENAME_DISK 9
#define ACTION_FREE_LOCK 15
#define ACTION_DELETE_OBJECT 16
#define ACTION_RENAME_OBJECT 17
#define ACTION_MORE_CACHE 18
#define ACTION_COPY_DIR 19
#define ACTION_SET_PROTECT 21
#define ACTION_CREATE_DIR 22
#define ACTION_EXAMINE_OBJECT 23
#define ACTION_EXAMINE_NEXT 24
#define ACTION_DISK_INFO 25
#define ACTION_INFO 26
#define ACTION_FLUSH 27
#define ACTION_SET_COMMENT 28
#define ACTION_PARENT 29
#define ACTION_SET_DATE 34
#define ACTION_FIND_WRITE 1004
#define ACTION_FIND_INPUT 1005
#define ACTION_FIND_OUTPUT 1006
#define ACTION_END 1007
#define ACTION_SEEK 1008
#define ACTION_WRITE_PROTECT 1023
#define ACTION_IS_FILESYSTEM 1027
#define ACTION_READ 'R'
#define ACTION_WRITE 'W'
/* 2.0+ packet types */
#define ACTION_INHIBIT 31
#define ACTION_SET_FILE_SIZE 1022
#define ACTION_LOCK_RECORD 2008
#define ACTION_FREE_RECORD 2009
#define ACTION_SAME_LOCK 40
#define ACTION_CHANGE_MODE 1028
#define ACTION_FH_FROM_LOCK 1026
#define ACTION_COPY_DIR_FH 1030
#define ACTION_PARENT_FH 1031
#define ACTION_EXAMINE_ALL 1033
#define ACTION_EXAMINE_FH 1034
#define ACTION_EXAMINE_ALL_END 1035
#define ACTION_FORMAT 1020
#define ACTION_IS_FILESYSTEM 1027
#define ACTION_ADD_NOTIFY 4097
#define ACTION_REMOVE_NOTIFY 4098
#define ACTION_READ_LINK 1024
/* OS4 64-bit filesize packets */
#define ACTION_CHANGE_FILE_POSITION64 8001
#define ACTION_GET_FILE_POSITION64 8002
#define ACTION_CHANGE_FILE_SIZE64 8003
#define ACTION_GET_FILE_SIZE64 8004
/* MOS 64-bit filesize packets */
#define ACTION_SEEK64 26400
#define ACTION_SET_FILE_SIZE64 26401
#define ACTION_LOCK_RECORD64 26402
#define ACTION_FREE_RECORD64 26403
#define ACTION_QUERY_ATTR 26407
#define ACTION_EXAMINE_OBJECT64 26408
#define ACTION_EXAMINE_NEXT64 26409
#define ACTION_EXAMINE_FH64 26410
/* not supported */
#define ACTION_MAKE_LINK 1021
#define DISK_TYPE_DOS 0x444f5300 /* DOS\0 */
#define DISK_TYPE_DOS_FFS 0x444f5301 /* DOS\1 */
#define CDFS_DOSTYPE 0x43440000 /* CDxx */
typedef struct {
uae_u32 uniq;
/* The directory we're going through. */
a_inode *aino;
/* The file we're going to look up next. */
a_inode *curr_file;
} ExamineKey;
struct lockrecord
{
struct lockrecord *next;
uae_u32 packet;
uae_u64 pos;
uae_u64 len;
uae_u32 mode;
uae_u32 timeout;
uae_u32 msg;
};
typedef struct key {
struct key *next;
a_inode *aino;
uae_u32 uniq;
struct fs_filehandle *fd;
uae_u64 file_pos;
int dosmode;
int createmode;
int notifyactive;
struct lockrecord *record;
} Key;
typedef struct notify {
struct notify *next;
uaecptr notifyrequest;
TCHAR *fullname;
TCHAR *partname;
} Notify;
typedef struct exallkey {
uae_u32 id;
struct fs_dirhandle *dirhandle;
TCHAR *fn;
uaecptr control;
} ExAllKey;
/* Since ACTION_EXAMINE_NEXT is so braindamaged, we have to keep
* some of these around
*/
#define EXKEYS 128
#define EXALLKEYS 100
#define MAX_AINO_HASH 128
#define NOTIFY_HASH_SIZE 127
/* handler state info */
typedef struct _unit {
struct _unit *next;
/* Amiga stuff */
uaecptr dosbase;
uaecptr volume;
uaecptr port; /* Our port */
uaecptr locklist;
/* Native stuff */
uae_s32 unit; /* unit number */
UnitInfo ui; /* unit startup info */
TCHAR tmpbuf3[256];
/* Dummy message processing */
uaecptr dummy_message;
volatile unsigned int cmds_sent;
volatile unsigned int cmds_complete;
volatile unsigned int cmds_acked;
/* ExKeys */
ExamineKey examine_keys[EXKEYS];
int next_exkey;
unsigned long total_locked_ainos;
/* ExAll */
ExAllKey exalls[EXALLKEYS];
int exallid;
/* Keys */
struct key *keys;
struct lockrecord *waitingrecords;
a_inode rootnode;
unsigned long aino_cache_size;
a_inode *aino_hash[MAX_AINO_HASH];
unsigned long nr_cache_hits;
unsigned long nr_cache_lookups;
struct notify *notifyhash[NOTIFY_HASH_SIZE];
int volflags;
uae_u32 lockkey;
bool inhibited;
bool canremovable;
/* increase when media is changed.
* used to detect if cached aino is valid
*/
int mountcount;
int mount_changed;
struct zvolume *zarchive;
void *cdfs_superblock;
TCHAR *mount_volume;
TCHAR *mount_rootdir;
bool mount_readonly;
int mount_flags;
int reinsertdelay;
TCHAR *newvolume;
TCHAR *newrootdir;
bool newreadonly;
int newflags;
} Unit;
static uae_u32 a_uniq, key_uniq;
static void set_quadp(uaecptr p, uae_s64 v)
{
if (!valid_address(p, 8))
return;
put_long(p, v >> 32);
put_long(p + 4, (uae_u64)v);
}
static uae_u64 get_quadp(uaecptr p)
{
if (!valid_address(p, 8))
return 0;
return ((uae_u64)get_long(p) << 32) | get_long(p + 4);
}
typedef uaecptr dpacket;
#define PUT_PCK_RES1(p,v) do { put_long ((p) + dp_Res1, (v)); } while (0)
#define PUT_PCK_RES2(p,v) do { put_long ((p) + dp_Res2, (v)); } while (0)
#define GET_PCK_TYPE(p) ((uae_s32)(get_long ((p) + dp_Type)))
#define GET_PCK_RES1(p) ((uae_s32)(get_long ((p) + dp_Res1)))
#define GET_PCK_RES2(p) ((uae_s32)(get_long ((p) + dp_Res2)))
#define GET_PCK_ARG1(p) ((uae_s32)(get_long ((p) + dp_Arg1)))
#define GET_PCK_ARG2(p) ((uae_s32)(get_long ((p) + dp_Arg2)))
#define GET_PCK_ARG3(p) ((uae_s32)(get_long ((p) + dp_Arg3)))
#define GET_PCK_ARG4(p) ((uae_s32)(get_long ((p) + dp_Arg4)))
#define GET_PCK_ARG5(p) ((uae_s32)(get_long ((p) + dp_Arg5)))
#define PUT_PCK64_RES0(p,v) do { put_long ((p) + dp64_Res0, (v)); } while (0)
#define PUT_PCK64_RES1(p,v) do { put_long ((p) + dp64_Res1, (((uae_u64)v) >> 32)); put_long ((p) + dp64_Res1 + 4, ((uae_u32)v)); } while (0)
#define PUT_PCK64_RES2(p,v) do { put_long ((p) + dp64_Res2, (v)); } while (0)
#define GET_PCK64_TYPE(p) ((uae_s32)(get_long ((p) + dp64_Type)))
#define GET_PCK64_RES0(p) ((uae_s32)(get_long ((p) + dp64_Res0)))
#define GET_PCK64_RES1(p) ( (((uae_s64)(get_long ((p) + dp64_Res1))) << 32) | (((uae_s64)(get_long ((p) + dp64_Res1 + 4))) << 0) )
#define GET_PCK64_ARG1(p) ((uae_s32)(get_long ((p) + dp64_Arg1)))
#define GET_PCK64_ARG2(p) ( (((uae_s64)(get_long ((p) + dp64_Arg2))) << 32) | (((uae_s64)(get_long ((p) + dp64_Arg2 + 4))) << 0) )
#define GET_PCK64_ARG3(p) ((uae_s32)(get_long ((p) + dp64_Arg3)))
#define GET_PCK64_ARG4(p) ((uae_s32)(get_long ((p) + dp64_Arg4)))
#define GET_PCK64_ARG5(p) ( (((uae_s64)(get_long ((p) + dp64_Arg5))) << 32) | (((uae_s64)(get_long ((p) + dp64_Arg5 + 4))) << 0) )
static int flush_cache (Unit *unit, int num);
static TCHAR *char1 (uaecptr addr)
{
static uae_char buf[1024];
static TCHAR bufx[1024];
unsigned int i = 0;
do {
buf[i] = get_byte (addr);
addr++;
} while (buf[i++] && i < sizeof (buf));
return au_fs_copy (bufx, sizeof (bufx) / sizeof (TCHAR), buf);
}
static TCHAR *bstr1 (uaecptr addr)
{
static TCHAR bufx[257];
static uae_char buf[257];
int i;
int n = get_byte (addr);
addr++;
for (i = 0; i < n; i++, addr++)
buf[i] = get_byte (addr);
buf[i] = 0;
return au_fs_copy (bufx, sizeof (bufx) / sizeof (TCHAR), buf);
}
static TCHAR *bstr (Unit *unit, uaecptr addr)
{
int i;
int n = get_byte (addr);
uae_char buf[257];
addr++;
for (i = 0; i < n; i++, addr++)
buf[i] = get_byte (addr);
buf[i] = 0;
au_fs_copy (unit->tmpbuf3, sizeof (unit->tmpbuf3) / sizeof (TCHAR), buf);
return unit->tmpbuf3;
}
static TCHAR *cstr (Unit *unit, uaecptr addr)
{
int i;
uae_char buf[257];
for (i = 0;;i++,addr++) {
buf[i] = get_byte (addr);
if (!buf[i])
break;
}
au_fs_copy (unit->tmpbuf3, sizeof (unit->tmpbuf3) / sizeof (TCHAR), buf);
return unit->tmpbuf3;
}
static TCHAR *bstr_cut (Unit *unit, uaecptr addr)
{
TCHAR *p = unit->tmpbuf3;
int i, colon_seen = 0, off;
int n = get_byte (addr);
uae_char buf[257];
off = 0;
addr++;
for (i = 0; i < n; i++, addr++) {
uae_u8 c = get_byte (addr);
buf[i] = c;
if (c == '/' || (c == ':' && colon_seen++ == 0))
off = i + 1;
}
buf[i] = 0;
au_fs_copy (unit->tmpbuf3, sizeof (unit->tmpbuf3) / sizeof (TCHAR), buf);
return &p[off];
}
/* convert time_t to/from AmigaDOS time */
static const uae_s64 msecs_per_day = 24 * 60 * 60 * 1000;
static const uae_s64 diff = ((8 * 365 + 2) * (24 * 60 * 60)) * (uae_u64)1000;
void timeval_to_amiga (struct mytimeval *tv, int *days, int *mins, int *ticks, int tickcount)
{
/* tv.tv_sec is secs since 1-1-1970 */
/* days since 1-1-1978 */
/* mins since midnight */
/* ticks past minute @ 50Hz */
uae_s64 t = tv->tv_sec * 1000 + tv->tv_usec / 1000;
t -= diff;
if (t < 0)
t = 0;
*days = t / msecs_per_day;
t -= *days * msecs_per_day;
*mins = t / (60 * 1000);
t -= *mins * (60 * 1000);
*ticks = t / (1000 / tickcount);
}
void amiga_to_timeval (struct mytimeval *tv, int days, int mins, int ticks, int tickcount)
{
uae_s64 t;
if (days < 0)
days = 0;
if (days > 9900 * 365)
days = 9900 * 365; // in future far enough?
if (mins < 0 || mins >= 24 * 60)
mins = 0;
if (ticks < 0 || ticks >= 60 * tickcount)
ticks = 0;
t = ticks * 20;
t += mins * (60 * 1000);
t += ((uae_u64)days) * msecs_per_day;
t += diff;
tv->tv_sec = t / 1000;
tv->tv_usec = (t % 1000) * 1000;
}
static Unit *units = 0;
static Unit*
find_unit (uaecptr port)
{
Unit* u;
for (u = units; u; u = u->next)
if (u->port == port)
break;
return u;
}
static struct fs_dirhandle *fs_opendir (Unit *u, a_inode *aino)
{
struct fs_dirhandle *fsd = xmalloc (struct fs_dirhandle, 1);
fsd->fstype = (u->volflags & MYVOLUMEINFO_ARCHIVE) ? FS_ARCHIVE : ((u->volflags & MYVOLUMEINFO_CDFS) ? FS_CDFS : FS_DIRECTORY);
if (fsd->fstype == FS_ARCHIVE) {
fsd->zd = zfile_opendir_archive (aino->nname);
if (fsd->zd)
return fsd;
} else if (fsd->fstype == FS_DIRECTORY) {
fsd->od = my_opendir (aino->nname);
if (fsd->od)
return fsd;
} else if (fsd->fstype == FS_CDFS) {
fsd->isod = isofs_opendir (u->ui.cdfs_superblock, aino->uniq_external);
if (fsd->isod)
return fsd;
}
xfree (fsd);
return NULL;
}
static void fs_closedir (struct fs_dirhandle *fsd)
{
if (!fsd)
return;
if (fsd->fstype == FS_ARCHIVE)
zfile_closedir_archive (fsd->zd);
else if (fsd->fstype == FS_DIRECTORY)
my_closedir (fsd->od);
else if (fsd->fstype == FS_CDFS)
isofs_closedir (fsd->isod);
xfree (fsd);
}
static struct fs_filehandle *fs_openfile (Unit *u, a_inode *aino, int flags)
{
struct fs_filehandle *fsf = xmalloc (struct fs_filehandle, 1);
fsf->fstype = (u->volflags & MYVOLUMEINFO_ARCHIVE) ? FS_ARCHIVE : ((u->volflags & MYVOLUMEINFO_CDFS) ? FS_CDFS : FS_DIRECTORY);
if (fsf->fstype == FS_ARCHIVE) {
fsf->zf = zfile_open_archive (aino->nname, flags);
if (fsf->zf)
return fsf;
} else if (fsf->fstype == FS_DIRECTORY) {
fsf->of = my_open (aino->nname, flags);
if (fsf->of)
return fsf;
} else if (fsf->fstype == FS_CDFS) {
fsf->isof = isofs_openfile (u->ui.cdfs_superblock, aino->uniq_external, flags);
if (fsf->isof)
return fsf;
}
xfree (fsf);
return NULL;
}
static void fs_closefile (struct fs_filehandle *fsf)
{
if (!fsf)
return;
if (fsf->fstype == FS_ARCHIVE) {
zfile_close_archive (fsf->zf);
} else if (fsf->fstype == FS_DIRECTORY) {
my_close (fsf->of);
} else if (fsf->fstype == FS_CDFS) {
isofs_closefile (fsf->isof);
}
xfree (fsf);
}
static unsigned int fs_read (struct fs_filehandle *fsf, void *b, unsigned int size)
{
if (fsf->fstype == FS_ARCHIVE)
return zfile_read_archive (fsf->zf, b, size);
else if (fsf->fstype == FS_DIRECTORY)
return my_read (fsf->of, b, size);
else if (fsf->fstype == FS_CDFS)
return isofs_read (fsf->isof, b, size);
return 0;
}
static unsigned int fs_write (struct fs_filehandle *fsf, void *b, unsigned int size)
{
if (fsf->fstype == FS_DIRECTORY)
return my_write (fsf->of, b, size);
return 0;
}
/* return value = old position. -1 = error. */
static uae_s64 fs_lseek64 (struct fs_filehandle *fsf, uae_s64 offset, int whence)
{
if (fsf->fstype == FS_ARCHIVE)
return zfile_lseek_archive (fsf->zf, offset, whence);
else if (fsf->fstype == FS_DIRECTORY)
return my_lseek (fsf->of, offset, whence);
else if (fsf->fstype == FS_CDFS)
return isofs_lseek (fsf->isof, offset, whence);
return -1;
}
static uae_s32 fs_lseek (struct fs_filehandle *fsf, uae_s32 offset, int whence)
{
uae_s64 v = fs_lseek64 (fsf, offset, whence);
if (v < 0 || v > 0x7fffffff)
return -1;
return (uae_s32)v;
}
static uae_s64 fs_fsize64 (struct fs_filehandle *fsf)
{
if (fsf->fstype == FS_ARCHIVE)
return zfile_fsize_archive (fsf->zf);
else if (fsf->fstype == FS_DIRECTORY)
return my_fsize (fsf->of);
else if (fsf->fstype == FS_CDFS)
return isofs_fsize (fsf->isof);
return -1;
}
static uae_u32 fs_fsize (struct fs_filehandle *fsf)
{
return (uae_u32)fs_fsize64 (fsf);
}
static uae_s64 key_filesize(Key *k)
{
if (k->aino->vfso)
return k->aino->vfso->size;
return fs_fsize64 (k->fd);
}
static uae_s64 key_seek(Key *k, uae_s64 offset, int whence)
{
if (k->aino->vfso)
return k->file_pos;
return fs_lseek64 (k->fd, offset, whence);
}
static void set_highcyl (UnitInfo *ui, uae_u32 blocks)
{
uaecptr startup = get_long (ui->devicenode + 7 * 4) << 2;
uaecptr env = get_long (startup + 8) << 2;
put_long (env + 10 * 4, blocks);
}
static void set_volume_name (Unit *unit, struct mytimeval *tv)
{
int namelen;
int i;
char *s;
s = ua_fs (unit->ui.volname, -1);
namelen = strlen (s);
put_byte (unit->volume + 44, namelen);
for (i = 0; i < namelen; i++)
put_byte (unit->volume + 45 + i, s[i]);
put_byte (unit->volume + 45 + namelen, 0);
if (tv && (tv->tv_sec || tv->tv_usec)) {
int days, mins, ticks;
timeval_to_amiga (tv, &days, &mins, &ticks, 50);
put_long (unit->volume + 16, days);
put_long (unit->volume + 20, mins);
put_long (unit->volume + 24, ticks);
}
xfree (s);
unit->rootnode.aname = unit->ui.volname;
unit->rootnode.nname = unit->ui.rootdir;
unit->rootnode.mountcount = unit->mountcount;
}
static int filesys_isvolume (Unit *unit)
{
if (!unit->volume)
return 0;
return get_byte (unit->volume + 44) || unit->ui.unknown_media;
}
static void clear_exkeys (Unit *unit)
{
int i;
a_inode *a;
for (i = 0; i < EXKEYS; i++) {
unit->examine_keys[i].aino = 0;
unit->examine_keys[i].curr_file = 0;
unit->examine_keys[i].uniq = 0;
}
for (i = 0; i < EXALLKEYS; i++) {
fs_closedir (unit->exalls[i].dirhandle);
unit->exalls[i].dirhandle = NULL;
xfree (unit->exalls[i].fn);
unit->exalls[i].fn = NULL;
unit->exalls[i].id = 0;
}
unit->exallid = 0;
unit->next_exkey = 1;
a = &unit->rootnode;
while (a) {
a->exnext_count = 0;
if (a->locked_children) {
a->locked_children = 0;
unit->total_locked_ainos--;
}
a = a->next;
if (a == &unit->rootnode)
break;
}
}
static void filesys_delayed_change (Unit *u, int frames, const TCHAR *rootdir, const TCHAR *volume, bool readonly, int flags)
{
u->reinsertdelay = 50;
u->newflags = flags;
u->newreadonly = readonly;
u->newrootdir = my_strdup (rootdir);
if (volume)
u->newvolume = my_strdup (volume);
filesys_eject (u->unit);
if (!rootdir || _tcslen (rootdir) == 0)
u->reinsertdelay = 0;
if (u->reinsertdelay > 0)
write_log (_T("FILESYS: delayed insert %d: '%s' ('%s')\n"), u->unit, volume ? volume : _T("<none>"), rootdir);
}
int filesys_eject (int nr)
{
UnitInfo *ui = &mountinfo.ui[nr];
Unit *u = ui->self;
if (!mountertask || u->mount_changed)
return 0;
if (ui->open <= 0 || u == NULL)
return 0;
if (!is_virtual (nr))
return 0;
if (!filesys_isvolume (u))
return 0;
u->mount_changed = -1;
u->mountcount++;
write_log (_T("FILESYS: volume '%s' removal request\n"), u->ui.volname);
// -1 = remove, -2 = remove + remove device node
put_byte (u->volume + 172 - 32, ui->unit_type == UNIT_CDFS ? -1 : -2);
uae_Signal (get_long (u->volume + 176 - 32), 1 << 13);
return 1;
}
static uae_u32 heartbeat;
static int heartbeat_count;
static int heartbeat_task;
// This uses filesystem process to reduce resource usage
void setsystime (void)
{
if (!currprefs.tod_hack || !rtarea_base)
return;
heartbeat = get_long (rtarea_base + RTAREA_HEARTBEAT);
heartbeat_task = 1;
heartbeat_count = 10;
}
static void setsystime_vblank (void)
{
Unit *u;
for (u = units; u; u = u->next) {
if (is_virtual (u->unit) && filesys_isvolume (u)) {
put_byte (u->volume + 173 - 32, 1);
uae_Signal (get_long (u->volume + 176 - 32), 1 << 13);
break;
}
}
}
int filesys_insert (int nr, const TCHAR *volume, const TCHAR *rootdir, bool readonly, int flags)
{
UnitInfo *ui;
Unit *u;
if (!mountertask)
return 0;
write_log (_T("filesys_insert(%d,'%s','%s','%d','%d)\n"), nr, volume ? volume : _T("<?>"), rootdir, readonly, flags);
if (nr < 0) {
for (u = units; u; u = u->next) {
if (is_virtual (u->unit)) {
if (!filesys_isvolume (u) && mountinfo.ui[u->unit].canremove)
break;
}
}
if (!u) {
for (u = units; u; u = u->next) {
if (is_virtual (u->unit)) {
if (mountinfo.ui[u->unit].canremove)
break;
}
}
}
if (!u)
return 0;
nr = u->unit;
ui = &mountinfo.ui[nr];
} else {
ui = &mountinfo.ui[nr];
u = ui->self;
}
if (ui->open <= 0 || u == NULL)
return 0;
if (u->reinsertdelay)
return -1;
if (!is_virtual (nr))
return 0;
if (filesys_isvolume (u)) {
filesys_delayed_change (u, 50, rootdir, volume, readonly, flags);
return -1;
}
u->mountcount++;
u->mount_changed = 1;
u->mount_volume = volume ? my_strdup (volume) : NULL;
u->mount_rootdir = my_strdup (rootdir);
u->mount_readonly = readonly;
u->mount_flags = flags;
write_log (_T("filesys_insert %d done!\n"), nr);
put_byte (u->volume + 172 - 32, -3); // wait for insert
uae_Signal (get_long (u->volume + 176 - 32), 1 << 13);
return 100 + nr;
}
static uae_u32 filesys_media_change_reply (TrapContext *ctx, int mode)
{
int nr;
UnitInfo *ui = NULL;
Unit *u;
for (nr = 0; nr < MAX_FILESYSTEM_UNITS; nr++) {
ui = &mountinfo.ui[nr];
u = ui->self;
if (u && u->mount_changed)
break;
}
if (nr >= MAX_FILESYSTEM_UNITS) {
write_log (_T("FILESYS: filesys_media_change_reply without mount_changed flag!?\n"));
return 0;
}
if (u->mount_changed < 0) {
// eject
if (mode == 0) {
write_log (_T("FILESYS: got media change reply, '%s' removal finished\n"), u->ui.volname);
flush_cache (u, -1);
isofs_unmount (u->ui.cdfs_superblock);
ui->cdfs_superblock = u->ui.cdfs_superblock = NULL;
zfile_fclose_archive (u->zarchive);
u->zarchive = NULL;
u->ui.unknown_media = false;
#ifdef RETROPLATFORM
if (ui->unit_type == UNIT_CDFS)
rp_cd_image_change (ui->cddevno, NULL);
else
rp_harddrive_image_change (nr, false, NULL);
#endif
} else {
u->mount_changed = 0;
}
return 1;
} else if (u->mount_changed > 0) {
if (mode == 0) {
// insert
struct mytimeval ctime = { 0 };
bool emptydrive = false;
struct uaedev_config_data *uci = NULL;
clear_exkeys (u);
xfree (u->ui.rootdir);
ui->rootdir = u->ui.rootdir = my_strdup (u->mount_rootdir);
flush_cache (u, -1);
xfree (u->ui.volname);
ui->volname = u->ui.volname = NULL;
if (ui->unit_type == UNIT_CDFS) {
uae_u64 uniq;
ui->cdfs_superblock = u->ui.cdfs_superblock = isofs_mount (ui->cddevno, &uniq);
u->rootnode.uniq_external = uniq;
u->ui.unknown_media = true;
if (!u->ui.cdfs_superblock)
return 0;
struct isofs_info ii;
set_highcyl (ui, 0);
bool r = isofs_mediainfo (ui->cdfs_superblock, &ii);
if (r && ii.media) {
u->ui.unknown_media = ii.unknown_media;
if (!ii.unknown_media) {
u->ui.volname = ui->volname = my_strdup (ii.volumename);
ctime.tv_sec = ii.creation;
ctime.tv_usec = 0;
set_highcyl (ui, ii.blocks);
#ifdef RETROPLATFORM
rp_cd_image_change (ui->cddevno, ii.devname);
#endif
}
}
} else {
if (set_filesys_volume (u->mount_rootdir, &u->mount_flags, &u->mount_readonly, &emptydrive, &u->zarchive) < 0)
return 0;
if (emptydrive)
return 0;
xfree (u->ui.volname);
ui->volname = u->ui.volname = filesys_createvolname (u->mount_volume, u->mount_rootdir, u->zarchive, _T("removable"));
#ifdef RETROPLATFORM
rp_harddrive_image_change (nr, u->mount_readonly, u->mount_rootdir);
#endif
uci = getuci (currprefs.mountconfig, nr);
}
if (u->ui.unknown_media) {
write_log (_T("FILESYS: inserted unreadable volume NR=%d RO=%d\n"), nr, u->mount_readonly);
} else {
write_log (_T("FILESYS: inserted volume NR=%d RO=%d '%s' ('%s')\n"), nr, u->mount_readonly, ui->volname, u->mount_rootdir);
set_volume_name (u, &ctime);
if (u->mount_flags >= 0)
ui->volflags = u->volflags = u->ui.volflags = u->mount_flags;
if (uci != NULL) {
_tcscpy (uci->ci.volname, ui->volname);
_tcscpy (uci->ci.rootdir, u->mount_rootdir);
}
if (u->mount_flags >= 0) {
ui->readonly = u->ui.readonly = u->mount_readonly;
if (uci != NULL)
uci->ci.readonly = u->mount_readonly;
}
put_byte (u->volume + 44, 0);
put_byte (u->volume + 172 - 32, 1);
}
xfree (u->mount_volume);
xfree (u->mount_rootdir);
u->mount_rootdir = NULL;
u->mount_volume = NULL;
} else {
u->mount_changed = 0;
}
return 1;
}
return 0;
}
int filesys_media_change (const TCHAR *rootdir, int inserted, struct uaedev_config_data *uci)
{
Unit *u;
UnitInfo *ui;
int nr = -1;
TCHAR volname[MAX_DPATH], *volptr;
TCHAR devname[MAX_DPATH];
if (!mountertask)
return 0;
if (automountunit >= 0)
return -1;
write_log (_T("filesys_media_change('%s',%d,%p)\n"), rootdir, inserted, uci);
nr = -1;
for (u = units; u; u = u->next) {
if (is_virtual (u->unit)) {
ui = &mountinfo.ui[u->unit];
// inserted == 2: drag&drop insert, do not replace existing normal drives
if (inserted < 2 && ui->rootdir && !memcmp (ui->rootdir, rootdir, _tcslen (rootdir)) && _tcslen (rootdir) + 3 >= _tcslen (ui->rootdir)) {
if (filesys_isvolume (u) && inserted) {
if (uci)
filesys_delayed_change (u, 50, rootdir, uci->ci.volname, uci->ci.readonly, 0);
return 0;
}
nr = u->unit;
break;
}
}
}
ui = NULL;
if (nr >= 0)
ui = &mountinfo.ui[nr];
/* only configured drives have automount support if automount is disabled */
if (!currprefs.win32_automount_removable && (!ui || !ui->configureddrive) && (inserted == 0 || inserted == 1))
return 0;
if (nr < 0 && !inserted)
return 0;
/* already mounted volume was ejected? */
if (nr >= 0 && !inserted)
return filesys_eject (nr);
if (inserted) {
struct uaedev_config_info ci = { 0 };
if (uci) {
volptr = my_strdup (uci->ci.volname);
} else {
volname[0] = 0;
target_get_volume_name (&mountinfo, rootdir, volname, MAX_DPATH, 1, 0);
volptr = volname;
if (!volname[0])
volptr = NULL;
if (ui && ui->configureddrive && ui->volname) {
volptr = volname;
_tcscpy (volptr, ui->volname);
}
}
if (!volptr) {
volptr = filesys_createvolname (NULL, rootdir, NULL, _T("removable"));
_tcscpy (volname, volptr);
xfree (volptr);
volptr = volname;
}
/* new volume inserted and it was previously mounted? */
if (nr >= 0) {
if (!filesys_isvolume (u)) /* not going to mount twice */
return filesys_insert (nr, volptr, rootdir, false, -1);
return 0;
}
if (inserted < 0) /* -1 = only mount if already exists */
return 0;
/* new volume inserted and it was not previously mounted?
* perhaps we have some empty device slots? */
nr = filesys_insert (-1, volptr, rootdir, 0, 0);
if (nr >= 100) {
if (uci)
uci->configoffset = nr - 100;
return nr;
}
/* nope, uh, need black magic now.. */
if (uci)
_tcscpy (devname, uci->ci.devname);
else
_stprintf (devname, _T("RDH%d"), autocreatedunit++);
_tcscpy (ci.devname, devname);
_tcscpy (ci.volname, volptr);
_tcscpy (ci.rootdir, rootdir);
ci.flags = MYVOLUMEINFO_REUSABLE;
nr = add_filesys_unit (&ci);
if (nr < 0)
return 0;
if (inserted > 1)
mountinfo.ui[nr].canremove = 1;
automountunit = nr;
uae_Signal (mountertask, 1 << 13);
/* poof */
if (uci)
uci->configoffset = nr;
return 100 + nr;
}
return 0;
}
int hardfile_added (struct uaedev_config_info *ci)
{
if (ci->controller_type == HD_CONTROLLER_TYPE_PCMCIA_IDE) {
return gayle_add_pcmcia_ide_unit(ci);
} else if (ci->controller_type == HD_CONTROLLER_TYPE_PCMCIA_SRAM) {
return gayle_add_pcmcia_sram_unit(ci);
}
return 0;
}
int hardfile_media_change (struct hardfiledata *hfd, struct uaedev_config_info *ci, bool inserted, bool timer)
{
if (!hfd)
return 0;
if (!timer)
hfd->reinsertdelay = 0;
if (hfd->reinsertdelay < 0) {
hfd->reinsertdelay = 0;
if (!hfd->isreinsert) {
hdf_close (hfd);
hardfile_send_disk_change (hfd, false);
if (hfd->delayedci.rootdir[0]) {
hfd->reinsertdelay = 50;
hfd->isreinsert = true;
write_log (_T("HARDFILE: delayed insert %d: '%s'\n"), hfd->unitnum, ci->rootdir ? ci->rootdir : _T("<none>"));
return 0;
} else {
return 1;
}
}
memcpy (&hfd->ci, &hfd->delayedci, sizeof (struct uaedev_config_info));
if (hdf_open (hfd) <= 0) {
write_log (_T("HARDFILE: '%s' failed to open\n"), hfd->ci.rootdir);
return 0;
}
hardfile_send_disk_change (hfd, true);
return 1;
}
if (ci) {
memcpy (&hfd->delayedci, ci, sizeof (struct uaedev_config_info));
if (hfd && !hfd->drive_empty) {
hfd->reinsertdelay = 50;
hfd->isreinsert = false;
write_log (_T("HARDFILE: delayed eject %d: '%s'\n"), hfd->unitnum, hfd->ci.rootdir ? hfd->ci.rootdir : _T("<none>"));
return 0;
}
if (!hfd) {
return 0;
}
hfd->reinsertdelay = 2;
hfd->isreinsert = true;
} else {
if (inserted) {
hfd->reinsertdelay = 2;
hfd->isreinsert = true;
memcpy (&hfd->delayedci, &hfd->ci, sizeof (struct uaedev_config_info));
} else {
hfd->reinsertdelay = 2;
hfd->isreinsert = false;
memcpy (&hfd->delayedci, &hfd->ci, sizeof (struct uaedev_config_info));
hfd->delayedci.rootdir[0] = 0;
}
}
return 0;
}
int hardfile_remount (int nr)
{
/* this does work but every media reinsert duplicates the device.. */
#if 0
if (!mountertask)
return 0;
automountunit = nr;
uae_Signal (mountertask, 1 << 13);
#endif
return 1;
}
bool filesys_do_disk_change (int cdunitnum, bool insert)
{
int nr = cdunitnum + cd_unit_offset;
UnitInfo *ui = &mountinfo.ui[nr];
Unit *u = ui->self;
if (!ui->cd_open)
return false;
if (insert) {
if (filesys_isvolume (u))
return false;
filesys_insert (nr, NULL, _T("/"), true, MYVOLUMEINFO_CDFS | MYVOLUMEINFO_READONLY);
return true;
} else {
if (!filesys_isvolume (u))
return false;
filesys_eject (nr);
return true;
}
}
/* flags and comments supported? */
static int fsdb_cando (Unit *unit)
{
if (unit->volflags & (MYVOLUMEINFO_ARCHIVE | MYVOLUMEINFO_CDFS))
return 1;
if (currprefs.filesys_custom_uaefsdb && (unit->volflags & MYVOLUMEINFO_STREAMS))
return 1;
if (!currprefs.filesys_no_uaefsdb)
return 1;
return 0;
}
static void prepare_for_open (TCHAR *name)
{
}
static void de_recycle_aino (Unit *unit, a_inode *aino)
{
aino_test (aino);
if (aino->next == 0 || aino == &unit->rootnode)
return;
aino->next->prev = aino->prev;
aino->prev->next = aino->next;
aino->next = aino->prev = 0;
unit->aino_cache_size--;
}
static void dispose_aino (Unit *unit, a_inode **aip, a_inode *aino)
{
int hash = aino->uniq % MAX_AINO_HASH;
if (unit->aino_hash[hash] == aino)
unit->aino_hash[hash] = 0;
if (aino->dirty && aino->parent)
fsdb_dir_writeback (aino->parent);
*aip = aino->sibling;
if (unit->volflags & MYVOLUMEINFO_ARCHIVE) {
;
} else if (unit->volflags & MYVOLUMEINFO_CDFS) {
isofs_dispose_inode (unit->ui.cdfs_superblock, aino->uniq_external);
}
xfree (aino->aname);
xfree (aino->comment);
xfree (aino->nname);
xfree (aino);
}
static void free_all_ainos (Unit *u, a_inode *parent)
{
a_inode *a;
while ((a = parent->child)) {
free_all_ainos (u, a);
dispose_aino (u, &parent->child, a);
}
}
static int flush_cache (Unit *unit, int num)
{
int i = 0;
int cnt = 100;
//write_log (_T("FILESYS: flushing cache unit %d (max %d items)\n"), unit->unit, num);
if (num == 0)
num = -1;
while (i < num || num < 0) {
int ii = i;
a_inode *parent = unit->rootnode.prev->parent;
a_inode **aip;
aip = &parent->child;
aino_test (parent);
if (parent && !parent->locked_children) {
for (;;) {
a_inode *aino = *aip;
aino_test (aino);
if (aino == 0)
break;
/* Not recyclable if next == 0 (i.e., not chained into
recyclable list), or if parent directory is being
ExNext()ed. */
if (aino->next == 0) {
aip = &aino->sibling;
} else {
if (aino->shlock > 0 || aino->elock)
write_log (_T("panic: freeing locked a_inode!\n"));
de_recycle_aino (unit, aino);
dispose_aino (unit, aip, aino);
i++;
}
}
}
{ //if (unit->rootnode.next != unit->rootnode.prev) {
/* In the previous loop, we went through all children of one
parent. Re-arrange the recycled list so that we'll find a
different parent the next time around.
(infinite loop if there is only one parent?)
*/
int maxloop = 10000;
do {
unit->rootnode.next->prev = unit->rootnode.prev;
unit->rootnode.prev->next = unit->rootnode.next;
unit->rootnode.next = unit->rootnode.prev;
unit->rootnode.prev = unit->rootnode.prev->prev;
unit->rootnode.prev->next = unit->rootnode.next->prev = &unit->rootnode;
} while (unit->rootnode.prev->parent == parent && maxloop-- > 0);
}
if (i == ii)
cnt--;
if (cnt <= 0)
break;
}
return unit->aino_cache_size > 0 ? 0 : 1;
}
static void recycle_aino (Unit *unit, a_inode *new_aino)
{
aino_test (new_aino);
if (new_aino->dir || new_aino->shlock > 0
|| new_aino->elock || new_aino == &unit->rootnode)
/* Still in use */
return;
TRACE3((_T("Recycling; cache size %d, total_locked %d\n"),
unit->aino_cache_size, unit->total_locked_ainos));
if (unit->aino_cache_size > 5000 + unit->total_locked_ainos) {
/* Reap a few. */
flush_cache (unit, 50);
#if 0
{
TCHAR buffer[40];
_stprintf (buffer, "%d ainos reaped.\n", i);
TRACE ((buffer));
}
#endif
}
aino_test (new_aino);
/* Chain it into circular list. */
new_aino->next = unit->rootnode.next;
new_aino->prev = &unit->rootnode;
new_aino->prev->next = new_aino;
new_aino->next->prev = new_aino;
aino_test (new_aino->next);
aino_test (new_aino->prev);
unit->aino_cache_size++;
}
void filesys_flush_cache (void)
{
}
static void update_child_names (Unit *unit, a_inode *a, a_inode *parent)
{
int l0 = _tcslen (parent->nname) + 2;
while (a != 0) {
TCHAR *name_start;
TCHAR *new_name;
TCHAR dirsep[2] = { FSDB_DIR_SEPARATOR, '\0' };
a->parent = parent;
name_start = _tcsrchr (a->nname, FSDB_DIR_SEPARATOR);
if (name_start == 0) {
write_log (_T("malformed file name"));
}
name_start++;
new_name = xmalloc (TCHAR, _tcslen (name_start) + l0);
_tcscpy (new_name, parent->nname);
_tcscat (new_name, dirsep);
_tcscat (new_name, name_start);
xfree (a->nname);
a->nname = new_name;
if (a->child)
update_child_names (unit, a->child, a);
a = a->sibling;
}
}
static void move_aino_children (Unit *unit, a_inode *from, a_inode *to)
{
aino_test (from);
aino_test (to);
to->child = from->child;
from->child = 0;
update_child_names (unit, to->child, to);
}
static void delete_aino (Unit *unit, a_inode *aino)
{
a_inode **aip;
TRACE((_T("deleting aino %x\n"), aino->uniq));
aino_test (aino);
aino->dirty = 1;
aino->deleted = 1;
de_recycle_aino (unit, aino);
/* If any ExKeys are currently pointing at us, advance them. */
if (aino->parent->exnext_count > 0) {
int i;
TRACE((_T("entering exkey validation\n")));
for (i = 0; i < EXKEYS; i++) {
ExamineKey *k = unit->examine_keys + i;
if (k->uniq == 0)
continue;
if (k->aino == aino->parent) {
TRACE((_T("Same parent found for %d\n"), i));
if (k->curr_file == aino) {
k->curr_file = aino->sibling;
TRACE((_T("Advancing curr_file\n")));
}
}
}
}
aip = &aino->parent->child;
while (*aip != aino && *aip != 0)
aip = &(*aip)->sibling;
if (*aip != aino) {
write_log (_T("Couldn't delete aino.\n"));
return;
}
dispose_aino (unit, aip, aino);
}
static a_inode *lookup_sub (a_inode *dir, uae_u32 uniq)
{
a_inode **cp = &dir->child;
a_inode *c, *retval;
for (;;) {
c = *cp;
if (c == 0)
return 0;
if (c->uniq == uniq) {
retval = c;
break;
}
if (c->dir) {
a_inode *a = lookup_sub (c, uniq);
if (a != 0) {
retval = a;
break;
}
}
cp = &c->sibling;
}
if (! dir->locked_children) {
/* Move to the front to speed up repeated lookups. Don't do this if
an ExNext is going on in this directory, or we'll terminally
confuse it. */
*cp = c->sibling;
c->sibling = dir->child;
dir->child = c;
}
return retval;
}
static a_inode *lookup_aino (Unit *unit, uae_u32 uniq)
{
a_inode *a;
int hash = uniq % MAX_AINO_HASH;
if (uniq == 0)
return &unit->rootnode;
a = unit->aino_hash[hash];
if (a == 0 || a->uniq != uniq)
a = lookup_sub (&unit->rootnode, uniq);
else
unit->nr_cache_hits++;
unit->nr_cache_lookups++;
unit->aino_hash[hash] = a;
aino_test (a);
return a;
}
static a_inode *aino_from_lock (Unit *unit, uaecptr lock)
{
return lookup_aino (unit, get_long (lock + 4));
}
TCHAR *build_nname (const TCHAR *d, const TCHAR *n)
{
TCHAR dsep[2] = { FSDB_DIR_SEPARATOR, 0 };
TCHAR *p = xmalloc (TCHAR, _tcslen (d) + 1 + _tcslen (n) + 1);
_tcscpy (p, d);
_tcscat (p, dsep);
_tcscat (p, n);
return p;
}
TCHAR *build_aname (const TCHAR *d, const TCHAR *n)
{
TCHAR *p = xmalloc (TCHAR, _tcslen (d) + 1 + _tcslen (n) + 1);
_tcscpy (p, d);
_tcscat (p, _T("/"));
_tcscat (p, n);
return p;
}
/* This gets called to translate an Amiga name that some program used to
* a name that we can use on the native filesystem. */
static TCHAR *get_nname (Unit *unit, a_inode *base, TCHAR *rel, TCHAR **modified_rel, uae_u64 *uniq_ext)
{
TCHAR *found;
TCHAR *p = 0;
*modified_rel = 0;
if (unit->volflags & MYVOLUMEINFO_ARCHIVE) {
if (zfile_exists_archive (base->nname, rel))
return build_nname (base->nname, rel);
return NULL;
} else if (unit->volflags & MYVOLUMEINFO_CDFS) {
if (isofs_exists (unit->ui.cdfs_superblock, base->uniq_external, rel, uniq_ext))
return build_nname (base->nname, rel);
return NULL;
}
aino_test (base);
/* If we have a mapping of some other aname to "rel", we must pretend
* it does not exist.
* This can happen for example if an Amiga program creates a
* file called ".". We can't represent this in our filesystem,
* so we create a special file "uae_xxx" and record the mapping
* aname "." -> nname "uae_xxx" in the database. Then, the Amiga
* program looks up "uae_xxx" (yes, it's contrived). The filesystem
* should not make the uae_xxx file visible to the Amiga side. */
if (fsdb_used_as_nname (base, rel))
return 0;
/* A file called "." (or whatever else is invalid on this filesystem)
* does not exist, as far as the Amiga side is concerned. */
if (fsdb_name_invalid_dir (rel))
return 0;
/* See if we have a file that has the same name as the aname we are
* looking for. */
found = fsdb_search_dir (base->nname, rel);
if (found == 0)
return found;
if (found == rel)
return build_nname (base->nname, rel);
*modified_rel = found;
return build_nname (base->nname, found);
}
static TCHAR *create_nname (Unit *unit, a_inode *base, TCHAR *rel)
{
TCHAR *p;
aino_test (base);
/* We are trying to create a file called REL. */
/* If the name is used otherwise in the directory (or globally), we
* need a new unique nname. */
if (fsdb_name_invalid (rel) || fsdb_used_as_nname (base, rel)) {
#if 0
oh_dear:
#endif
if (currprefs.filesys_no_uaefsdb && !(base->volflags & MYVOLUMEINFO_STREAMS)) {
write_log (_T("illegal filename '%s', no stream supporting filesystem and uaefsdb disabled\n"), rel);
return 0;
}
p = fsdb_create_unique_nname (base, rel);
return p;
}
p = build_nname (base->nname, rel);
#if 0
/* Delete this code once we know everything works. */
if (access (p, R_OK) >= 0 || errno != ENOENT) {
write_log (_T("Filesystem in trouble... please report.\n"));
xfree (p);
goto oh_dear;
}
#endif
return p;
}
static int fill_file_attrs (Unit *u, a_inode *base, a_inode *c)
{
if (u->volflags & MYVOLUMEINFO_ARCHIVE) {
int isdir, flags;
TCHAR *comment;
zfile_fill_file_attrs_archive (c->nname, &isdir, &flags, &comment);
c->dir = isdir;
c->amigaos_mode = 0;
if (flags >= 0)
c->amigaos_mode = flags;
c->comment = comment;
return 1;
} else if (u->volflags & MYVOLUMEINFO_CDFS) {
int isdir, flags;
TCHAR *comment;
isofss_fill_file_attrs (u->ui.cdfs_superblock, base->uniq_external, &isdir, &flags, &comment, c->uniq_external);
c->dir = isdir;
c->amigaos_mode = 0;
if (flags >= 0)
c->amigaos_mode = flags;
c->comment = comment;
return 1;
} else {
return fsdb_fill_file_attrs (base, c);
}
return 0;
}
static int test_softlink (a_inode *aino)
{
int err;
if (aino->softlink && my_resolvesoftlink (aino->nname, -1))
err = ERROR_IS_SOFT_LINK;
else
err = ERROR_OBJECT_NOT_AROUND;
return err;
}
static void handle_softlink (Unit *unit, dpacket packet, a_inode *aino)
{
PUT_PCK_RES1 (packet, DOS_FALSE);
PUT_PCK_RES2 (packet, test_softlink (aino));
}
/*
* This gets called if an ACTION_EXAMINE_NEXT happens and we hit an object
* for which we know the name on the native filesystem, but no corresponding
* Amiga filesystem name.
* @@@ For DOS filesystems, it might make sense to declare the new name
* "weak", so that it can get overriden by a subsequent call to get_nname().
* That way, if someone does "dir :" and there is a file "foobar.inf", and
* someone else tries to open "foobar.info", get_nname() could maybe made to
* figure out that this is supposed to be the file "foobar.inf".
* DOS sucks...
*/
static TCHAR *get_aname (Unit *unit, a_inode *base, TCHAR *rel)
{
return my_strdup (rel);
}
static void init_child_aino_tree (Unit *unit, a_inode *base, a_inode *aino)
{
/* Update tree structure */
aino->parent = base;
aino->child = 0;
aino->sibling = base->child;
base->child = aino;
aino->next = aino->prev = 0;
aino->volflags = unit->volflags;
}
static void init_child_aino (Unit *unit, a_inode *base, a_inode *aino)
{
aino->uniq = ++a_uniq;
if (a_uniq == 0xFFFFFFFF) {
write_log (_T("Running out of a_inodes (prepare for big trouble)!\n"));
}
aino->shlock = 0;
aino->elock = 0;
aino->dirty = 0;
aino->deleted = 0;
aino->mountcount = unit->mountcount;
/* For directories - this one isn't being ExNext()ed yet. */
aino->locked_children = 0;
aino->exnext_count = 0;
/* But the parent might be. */
if (base->exnext_count) {
unit->total_locked_ainos++;
base->locked_children++;
}
init_child_aino_tree (unit, base, aino);
aino_test_init (aino);
aino_test (aino);
}
static a_inode *new_child_aino (Unit *unit, a_inode *base, TCHAR *rel)
{
TCHAR *modified_rel;
TCHAR *nn;
a_inode *aino = NULL;
int isvirtual = unit->volflags & (MYVOLUMEINFO_ARCHIVE | MYVOLUMEINFO_CDFS);
TRACE((_T("new_child_aino %s, %s\n"), base->aname, rel));
if (!isvirtual)
aino = fsdb_lookup_aino_aname (base, rel);
if (aino == 0) {
uae_u64 uniq_ext = 0;
nn = get_nname (unit, base, rel, &modified_rel, &uniq_ext);
if (nn == 0)
return 0;
aino = xcalloc (a_inode, 1);
if (aino == 0)
return 0;
aino->uniq_external = uniq_ext;
aino->aname = modified_rel ? modified_rel : my_strdup (rel);
aino->nname = nn;
aino->comment = 0;
aino->has_dbentry = 0;
if (!fill_file_attrs (unit, base, aino)) {
xfree (aino);
return 0;
}
if (aino->dir && !isvirtual)
fsdb_clean_dir (aino);
}
init_child_aino (unit, base, aino);
recycle_aino (unit, aino);
TRACE((_T("created aino %x, lookup, amigaos_mode %d\n"), aino->uniq, aino->amigaos_mode));
return aino;
}
static a_inode *create_child_aino (Unit *unit, a_inode *base, TCHAR *rel, int isdir)
{
a_inode *aino = xcalloc (a_inode, 1);
if (aino == 0)
return 0;
aino->nname = create_nname (unit, base, rel);
if (!aino->nname) {
free (aino);
return 0;
}
aino->aname = my_strdup (rel);
init_child_aino (unit, base, aino);
aino->amigaos_mode = 0;
aino->dir = isdir;
aino->comment = 0;
aino->has_dbentry = 0;
aino->dirty = 1;
recycle_aino (unit, aino);
TRACE((_T("created aino %x, create\n"), aino->uniq));
return aino;
}
static a_inode *lookup_child_aino (Unit *unit, a_inode *base, TCHAR *rel, int *err)
{
a_inode *c = base->child;
int l0 = _tcslen (rel);
aino_test (base);
aino_test (c);
if (base->dir == 0) {
*err = ERROR_OBJECT_WRONG_TYPE;
return 0;
}
while (c != 0) {
int l1 = _tcslen (c->aname);
if (l0 <= l1 && same_aname (rel, c->aname + l1 - l0)
&& (l0 == l1 || c->aname[l1-l0-1] == '/') && c->mountcount == unit->mountcount)
break;
c = c->sibling;
}
if (c != 0)
return c;
c = new_child_aino (unit, base, rel);
if (c == 0)
*err = ERROR_OBJECT_NOT_AROUND;
return c;
}
/* Different version because for this one, REL is an nname. */
static a_inode *lookup_child_aino_for_exnext (Unit *unit, a_inode *base, TCHAR *rel, uae_u32 *err, uae_u64 uniq_external, struct virtualfilesysobject *vfso)
{
a_inode *c = base->child;
int l0 = _tcslen (rel);
int isvirtual = unit->volflags & (MYVOLUMEINFO_ARCHIVE | MYVOLUMEINFO_CDFS);
aino_test (base);
aino_test (c);
*err = 0;
while (c != 0) {
int l1 = _tcslen (c->nname);
/* Note: using _tcscmp here. */
if (l0 <= l1 && _tcscmp (rel, c->nname + l1 - l0) == 0
&& (l0 == l1 || c->nname[l1-l0-1] == FSDB_DIR_SEPARATOR) && c->mountcount == unit->mountcount)
break;
c = c->sibling;
}
if (c != 0)
return c;
if (!isvirtual && !vfso)
c = fsdb_lookup_aino_nname (base, rel);
if (c == 0) {
c = xcalloc (a_inode, 1);
if (c == 0) {
*err = ERROR_NO_FREE_STORE;
return 0;
}
c->nname = build_nname (base->nname, rel);
c->aname = get_aname (unit, base, rel);
c->comment = 0;
c->uniq_external = uniq_external;
c->has_dbentry = 0;
if (vfso) {
c->dir = vfso->dir;
c->comment = my_strdup(vfso->comment);
c->amigaos_mode = vfso->amigaos_mode;
c->vfso = vfso;
} else if (!fill_file_attrs (unit, base, c)) {
xfree (c);
*err = ERROR_NO_FREE_STORE;
return 0;
}
if (c->dir && !isvirtual && !vfso)
fsdb_clean_dir (c);
}
init_child_aino (unit, base, c);
recycle_aino (unit, c);
TRACE((_T("created aino %s:%d, exnext\n"), c->nname, c->uniq));
return c;
}
static a_inode *get_aino (Unit *unit, a_inode *base, const TCHAR *rel, int *err)
{
TCHAR *tmp;
TCHAR *p;
a_inode *curr, *prev;
int i;
aino_test (base);
*err = 0;
TRACE((_T("get_path(%s,%s)\n"), base->aname, rel));
/* root-relative path? */
for (i = 0; rel[i] && rel[i] != '/' && rel[i] != ':'; i++)
;
if (':' == rel[i])
rel += i+1;
tmp = my_strdup (rel);
p = tmp;
curr = base;
prev = NULL;
while (*p) {
/* start with a slash? go up a level. */
if (*p == '/') {
if (curr->parent != 0)
curr = curr->parent;
p++;
} else {
a_inode *next;
if (prev && prev->softlink) {
*err = test_softlink (prev);
curr = NULL;
break;
}
TCHAR *component_end;
component_end = _tcschr (p, '/');
if (component_end != 0)
*component_end = '\0';
next = lookup_child_aino (unit, curr, p, err);
if (next == 0) {
/* if only last component not found, return parent dir. */
if (*err != ERROR_OBJECT_NOT_AROUND || component_end != 0)
curr = NULL;
/* ? what error is appropriate? */
break;
}
prev = next;
curr = next;
if (component_end)
p = component_end+1;
else
break;
}
}
xfree (tmp);
return curr;
}
static uae_u32 notifyhash (const TCHAR *s)
{
uae_u32 hash = 0;
while (*s)
hash = (hash << 5) + *s++;
return hash % NOTIFY_HASH_SIZE;
}
static Notify *new_notify (Unit *unit, TCHAR *name)
{
Notify *n = xmalloc (Notify, 1);
uae_u32 hash = notifyhash (name);
n->next = unit->notifyhash[hash];
unit->notifyhash[hash] = n;
n->partname = name;
return n;
}
#if 0
static void free_notify_item (Notify *n)
{
xfree (n->fullname);
xfree (n->partname);
xfree (n);
}
#endif
static void free_notify (Unit *unit, int hash, Notify *n)
{
Notify *n1, *prev = 0;
for (n1 = unit->notifyhash[hash]; n1; n1 = n1->next) {
if (n == n1) {
if (prev)
prev->next = n->next;
else
unit->notifyhash[hash] = n->next;
break;
}
prev = n1;
}
}
static void startup_update_unit (Unit *unit, UnitInfo *uinfo)
{
if (!unit)
return;
xfree (unit->ui.volname);
memcpy (&unit->ui, uinfo, sizeof (UnitInfo));
unit->ui.devname = uinfo->devname;
unit->ui.volname = my_strdup (uinfo->volname); /* might free later for rename */
}
static Unit *startup_create_unit (UnitInfo *uinfo, int num)
{
int i;
Unit *unit, *u;
unit = xcalloc (Unit, 1);
/* keep list in insertion order */
u = units;
if (u) {
while (u->next)
u = u->next;
u->next = unit;
} else {
units = unit;
}
uinfo->self = unit;
unit->volume = 0;
unit->port = m68k_areg (regs, 5);
unit->unit = num;
startup_update_unit (unit, uinfo);
unit->cmds_complete = 0;
unit->cmds_sent = 0;
unit->cmds_acked = 0;
clear_exkeys (unit);
unit->total_locked_ainos = 0;
unit->keys = 0;
for (i = 0; i < NOTIFY_HASH_SIZE; i++) {
Notify *n = unit->notifyhash[i];
while (n) {
Notify *n2 = n;
n = n->next;
xfree (n2->fullname);
xfree (n2->partname);
xfree (n2);
}
unit->notifyhash[i] = 0;
}
unit->rootnode.aname = uinfo->volname;
unit->rootnode.nname = uinfo->rootdir;
unit->rootnode.sibling = 0;
unit->rootnode.next = unit->rootnode.prev = &unit->rootnode;
unit->rootnode.uniq = 0;
unit->rootnode.parent = 0;
unit->rootnode.child = 0;
unit->rootnode.dir = 1;
unit->rootnode.amigaos_mode = 0;
unit->rootnode.shlock = 0;
unit->rootnode.elock = 0;
unit->rootnode.comment = 0;
unit->rootnode.has_dbentry = 0;
unit->rootnode.volflags = uinfo->volflags;
aino_test_init (&unit->rootnode);
unit->aino_cache_size = 0;
for (i = 0; i < MAX_AINO_HASH; i++)
unit->aino_hash[i] = 0;
return unit;
}
static bool mount_cd (UnitInfo *uinfo, int nr, struct mytimeval *ctime, uae_u64 *uniq)
{
uinfo->cddevno = nr - cd_unit_offset;
if (!sys_command_open (uinfo->cddevno)) {
write_log (_T("Failed attempt to open CD unit %d\n"), uinfo->cddevno);
return false;
}
#ifdef RETROPLATFORM
rp_cd_device_enable (uinfo->cddevno, true);
#endif
uinfo->cdfs_superblock = isofs_mount(uinfo->cddevno, uniq);
uinfo->wasisempty = true;
struct isofs_info ii;
if (isofs_mediainfo (uinfo->cdfs_superblock, &ii)) {
xfree (uinfo->volname);
if (ii.media) {
uinfo->wasisempty = false;
if (!ii.unknown_media) {
uinfo->volname = my_strdup (ii.volumename);
if (ctime) {
ctime->tv_sec = ii.creation;
ctime->tv_usec = 0;
}
set_highcyl (uinfo, ii.totalblocks);
#ifdef RETROPLATFORM
rp_cd_image_change (uinfo->cddevno, ii.devname);
#endif
}
}
uinfo->unknown_media = ii.unknown_media;
}
uinfo->cd_open = true;
return true;
}
#ifdef UAE_FILESYS_THREADS
static void *filesys_thread (void *unit_v);
#endif
static void filesys_start_thread (UnitInfo *ui, int nr)
{
ui->unit_pipe = 0;
ui->back_pipe = 0;
ui->reset_state = FS_STARTUP;
if (!isrestore ()) {
ui->startup = 0;
ui->self = 0;
}
#ifdef UAE_FILESYS_THREADS
if (is_virtual (nr)) {
ui->unit_pipe = xmalloc (smp_comm_pipe, 1);
ui->back_pipe = xmalloc (smp_comm_pipe, 1);
init_comm_pipe (ui->unit_pipe, 100, 3);
init_comm_pipe (ui->back_pipe, 100, 1);
uae_start_thread (_T("filesys"), filesys_thread, (void *)ui, &ui->tid);
}
#endif
if (isrestore ()) {
if (ui->unit_type == UNIT_CDFS) {
mount_cd (ui, nr, NULL, &ui->self->rootnode.uniq_external);
}
startup_update_unit (ui->self, ui);
}
}
static uae_u32 REGPARAM2 startup_handler (TrapContext *context)
{
/* Just got the startup packet. It's in D3. DosBase is in A2,
* our allocated volume structure is in A3, A5 is a pointer to
* our port. */
uaecptr rootnode = get_long (m68k_areg (regs, 2) + 34);
uaecptr dos_info = get_long (rootnode + 24) << 2;
uaecptr pkt = m68k_dreg (regs, 3);
uaecptr arg1 = get_long (pkt + dp_Arg1);
uaecptr arg2 = get_long (pkt + dp_Arg2);
uaecptr arg3 = get_long (pkt + dp_Arg3);
uaecptr devnode;
int nr;
Unit *unit;
UnitInfo *uinfo;
int late = 0;
int ed, ef;
uae_u64 uniq = 0;
uae_u32 cdays;
struct mytimeval ctime = { 0 };
// 1.3:
// dp_Arg1 contains crap (Should be name of device)
// dp_Arg2 = works as documented
// dp_Arg3 = NULL (!?). (Should be DeviceNode)
for (nr = 0; nr < MAX_FILESYSTEM_UNITS; nr++) {
/* Hardfile volume name? */
if (mountinfo.ui[nr].open <= 0)
continue;
if (!is_virtual (nr))
continue;
if (mountinfo.ui[nr].startup == arg2)
break;
}
if (nr == MAX_FILESYSTEM_UNITS) {
write_log (_T("Attempt to mount unknown filesystem device\n"));
put_long (pkt + dp_Res1, DOS_FALSE);
put_long (pkt + dp_Res2, ERROR_DEVICE_NOT_MOUNTED);
return 0;
}
uinfo = mountinfo.ui + nr;
//devnode = arg3 << 2;
devnode = uinfo->devicenode;
cdays = 3800 + nr;
if (uinfo->unit_type == UNIT_CDFS) {
ed = ef = 0;
if (!mount_cd (uinfo, nr, &ctime, &uniq)) {
put_long (pkt + dp_Res1, DOS_FALSE);
put_long (pkt + dp_Res2, ERROR_DEVICE_NOT_MOUNTED);
return 0;
}
} else {
ed = my_existsdir (uinfo->rootdir);
ef = my_existsfile (uinfo->rootdir);
if (!uinfo->wasisempty && !ef && !ed) {
write_log (_T("Failed attempt to mount device '%s' (%s)\n"), uinfo->devname, uinfo->rootdir);
put_long (pkt + dp_Res1, DOS_FALSE);
put_long (pkt + dp_Res2, ERROR_DEVICE_NOT_MOUNTED);
return 0;
}
}
if (!uinfo->unit_pipe) {
late = 1;
filesys_start_thread (uinfo, nr);
}
unit = startup_create_unit (uinfo, nr);
unit->volflags = uinfo->volflags;
unit->rootnode.uniq_external = uniq;
/* write_comm_pipe_int (unit->ui.unit_pipe, -1, 1);*/
write_log (_T("FS: %s (flags=%08X,E=%d,ED=%d,EF=%d,native='%s') starting..\n"),
unit->ui.volname, unit->volflags, uinfo->wasisempty, ed, ef, unit->ui.rootdir);
/* fill in our process in the device node */
put_long (devnode + 8, unit->port);
unit->dosbase = m68k_areg (regs, 2);
/* make new volume */
unit->volume = m68k_areg (regs, 3) + 32;
put_long (unit->volume + 180 - 32, devnode);
#ifdef UAE_FILESYS_THREADS
unit->locklist = m68k_areg (regs, 3) + 8;
#else
unit->locklist = m68k_areg (regs, 3);
#endif
unit->dummy_message = m68k_areg (regs, 3) + 12;
put_long (unit->dummy_message + 10, 0);
/* Prepare volume information */
put_long (unit->volume + 4, 2); /* Type = dt_volume */
put_long (unit->volume + 12, 0); /* Lock */
put_long (unit->volume + 16, cdays); /* Creation Date */
put_long (unit->volume + 20, 0);
put_long (unit->volume + 24, 0);
put_long (unit->volume + 28, 0); /* lock list */
put_long (unit->volume + 40, (unit->volume + 44) >> 2); /* Name */
put_byte (unit->volume + 44, 0);
if (!uinfo->wasisempty && !uinfo->unknown_media) {
int isvirtual = unit->volflags & (MYVOLUMEINFO_ARCHIVE | MYVOLUMEINFO_CDFS);
/* Set volume if non-empty */
set_volume_name (unit, &ctime);
if (!isvirtual)
fsdb_clean_dir (&unit->rootnode);
}
put_long (unit->volume + 8, unit->port);
put_long (unit->volume + 32, uinfo->unit_type == UNIT_CDFS ? DISK_TYPE_DOS : DISK_TYPE_DOS_FFS);
put_long (pkt + dp_Res1, DOS_TRUE);
return 1 | (late ? 2 : 0);
}
static void
do_info (Unit *unit, dpacket packet, uaecptr info, bool disk_info)
{
struct fs_usage fsu;
int ret, err = ERROR_NO_FREE_STORE;
int blocksize, nr;
uae_u32 dostype;
bool fs = false, media = false;
blocksize = 512;
/* not FFS because it is not understood by WB1.x C:Info */
dostype = DISK_TYPE_DOS;
nr = unit->unit;
if (unit->volflags & MYVOLUMEINFO_ARCHIVE) {
ret = zfile_fs_usage_archive (unit->ui.rootdir, 0, &fsu);
fs = true;
media = filesys_isvolume (unit) != 0;
} else if (unit->volflags & MYVOLUMEINFO_CDFS) {
struct isofs_info ii;
ret = isofs_mediainfo (unit->ui.cdfs_superblock, &ii) ? 0 : 1;
if (!ret) {
media = ii.media;
nr = unit->unit - cd_unit_offset;
blocksize = ii.blocksize;
if (ii.media) {
fsu.fsu_blocks = ii.blocks;
fsu.fsu_bavail = 0;
}
}
} else {
ret = get_fs_usage (unit->ui.rootdir, 0, &fsu);
if (ret)
err = dos_errno ();
fs = true;
media = filesys_isvolume (unit) != 0;
}
if (ret != 0) {
PUT_PCK_RES1 (packet, DOS_FALSE);
PUT_PCK_RES2 (packet, err);
return;
}
put_long (info, 0); /* errors */
put_long (info + 4, nr); /* unit number */
put_long (info + 8, unit->ui.readonly || unit->ui.locked ? 80 : 82); /* state */
put_long (info + 20, blocksize); /* bytesperblock */
put_long (info + 32, 0); /* inuse */
if (unit->ui.unknown_media) {
if (!disk_info) {
PUT_PCK_RES1 (packet, DOS_FALSE);
PUT_PCK_RES2 (packet, ERROR_NOT_A_DOS_DISK);
return;
}
put_long (info + 12, 0);
put_long (info + 16, 0);
put_long (info + 24, ('B' << 24) | ('A' << 16) | ('D' << 8) | (0 << 0)); /* ID_UNREADABLE_DISK */
put_long (info + 28, 0);
} else if (!media) {
if (!disk_info) {
PUT_PCK_RES1 (packet, DOS_FALSE);
PUT_PCK_RES2 (packet, ERROR_NO_DISK);
return;
}
put_long (info + 12, 0);
put_long (info + 16, 0);
put_long (info + 24, -1); /* ID_NO_DISK_PRESENT */
put_long (info + 28, 0);
} else {
if (fs && currprefs.filesys_limit) {
if (fsu.fsu_blocks > (uae_u64)currprefs.filesys_limit * 1024 / blocksize) {
uae_u32 oldblocks = fsu.fsu_blocks;
fsu.fsu_blocks = (uae_u32)((uae_u64)currprefs.filesys_limit * 1024 / blocksize);
fsu.fsu_bavail = (uae_u32)((uae_u64)fsu.fsu_bavail * fsu.fsu_blocks / oldblocks);
}
}
put_long (info + 12, fsu.fsu_blocks); /* numblocks */
put_long (info + 16, fsu.fsu_blocks - fsu.fsu_bavail); /* inuse */
put_long (info + 24, dostype); /* disk type */
put_long (info + 28, unit->volume >> 2); /* volume node */
put_long (info + 32, (get_long (unit->volume + 28) || unit->keys) ? -1 : 0); /* inuse */
}
PUT_PCK_RES1 (packet, DOS_TRUE);
}
static void
action_disk_info (Unit *unit, dpacket packet)
{
TRACE((_T("ACTION_DISK_INFO\n")));
do_info (unit, packet, GET_PCK_ARG1 (packet) << 2, true);
}
static void
action_info (Unit *unit, dpacket packet)
{
TRACE((_T("ACTION_INFO\n")));
do_info (unit, packet, GET_PCK_ARG2 (packet) << 2, false);
}
static void free_key (Unit *unit, Key *k)
{
Key *k1;
Key *prev = 0;
for (k1 = unit->keys; k1; k1 = k1->next) {
if (k == k1) {
if (prev)
prev->next = k->next;
else
unit->keys = k->next;
break;
}
prev = k1;
}
for (struct lockrecord *lr = k->record; lr;) {
struct lockrecord *next = lr->next;
xfree (lr);
lr = next;
}
if (k->fd != NULL)
fs_closefile (k->fd);
xfree(k);
}
static Key *lookup_key (Unit *unit, uae_u32 uniq)
{
Key *k;
unsigned int total = 0;
/* It's hardly worthwhile to optimize this - most of the time there are
* only one or zero keys. */
for (k = unit->keys; k; k = k->next) {
total++;
if (uniq == k->uniq)
return k;
}
write_log (_T("Error: couldn't find key %u / %u!\n"), uniq, total);
return 0;
}
static Key *new_key (Unit *unit)
{
Key *k = xcalloc (Key, 1);
k->uniq = ++key_uniq;
k->fd = NULL;
k->file_pos = 0;
k->next = unit->keys;
unit->keys = k;
return k;
}
#if TRACING_ENABLED
static void
dumplock (Unit *unit, uaecptr lock)
{
a_inode *a;
TRACE((_T("LOCK: 0x%lx"), lock));
if (!lock) {
TRACE((_T("\n")));
return;
}
TRACE((_T("{ next=0x%lx, mode=%ld, handler=0x%lx, volume=0x%lx, aino %lx "),
get_long (lock) << 2, get_long (lock + 8),
get_long (lock + 12), get_long (lock + 16),
get_long (lock + 4)));
a = aino_from_lock (unit, lock);
if (a == 0) {
TRACE((_T("not found!")));
} else {
TRACE((_T("%s"), a->nname));
}
TRACE((_T(" }\n")));
}
#endif
static a_inode *find_aino (Unit *unit, uaecptr lock, const TCHAR *name, int *err)
{
a_inode *a;
if (lock) {
a_inode *olda = aino_from_lock (unit, lock);
if (olda == 0) {
/* That's the best we can hope to do. */
a = get_aino (unit, &unit->rootnode, name, err);
} else {
TRACE((_T("aino: 0x%08lx"), (unsigned long int)olda->uniq));
TRACE((_T(" \"%s\"\n"), olda->nname));
a = get_aino (unit, olda, name, err);
}
} else {
a = get_aino (unit, &unit->rootnode, name, err);
}
if (a) {
TRACE((_T("aino=\"%s\"\n"), a->nname));
}
aino_test (a);
return a;
}
static uaecptr make_lock (Unit *unit, uae_u32 uniq, long mode)
{
/* allocate lock from the list kept by the assembly code */
uaecptr lock;
lock = get_long (unit->locklist);
put_long (unit->locklist, get_long (lock));
lock += 4;
put_long (lock + 4, uniq);
put_long (lock + 8, mode);
put_long (lock + 12, unit->port);
put_long (lock + 16, unit->volume >> 2);
/* prepend to lock chain */
put_long (lock, get_long (unit->volume + 28));
put_long (unit->volume + 28, lock >> 2);
DUMPLOCK(unit, lock);
return lock;
}
#define NOTIFY_CLASS 0x40000000
#define NOTIFY_CODE 0x1234
#define NRF_SEND_MESSAGE 1
#define NRF_SEND_SIGNAL 2
#define NRF_WAIT_REPLY 8
#define NRF_NOTIFY_INITIAL 16
#define NRF_MAGIC (1 << 31)
static void notify_send (Unit *unit, Notify *n)
{
uaecptr nr = n->notifyrequest;
int flags = get_long (nr + 12);
if (flags & NRF_SEND_MESSAGE) {
if (!(flags & NRF_WAIT_REPLY) || ((flags & NRF_WAIT_REPLY) && !(flags & NRF_MAGIC))) {
uae_NotificationHack (unit->port, nr);
} else if (flags & NRF_WAIT_REPLY) {
put_long (nr + 12, get_long (nr + 12) | NRF_MAGIC);
}
} else if (flags & NRF_SEND_SIGNAL) {
uae_Signal (get_long (nr + 16), 1 << get_byte (nr + 20));
}
}
static void notify_check (Unit *unit, a_inode *a)
{
Notify *n;
int hash = notifyhash (a->aname);
for (n = unit->notifyhash[hash]; n; n = n->next) {
uaecptr nr = n->notifyrequest;
if (same_aname (n->partname, a->aname)) {
int err;
a_inode *a2 = find_aino (unit, 0, n->fullname, &err);
if (err == 0 && a == a2)
notify_send (unit, n);
}
}
if (a->parent) {
hash = notifyhash (a->parent->aname);
for (n = unit->notifyhash[hash]; n; n = n->next) {
uaecptr nr = n->notifyrequest;
if (same_aname (n->partname, a->parent->aname)) {
int err;
a_inode *a2 = find_aino (unit, 0, n->fullname, &err);
if (err == 0 && a->parent == a2)
notify_send (unit, n);
}
}
}
}
static void
action_add_notify (Unit *unit, dpacket packet)
{
uaecptr nr = GET_PCK_ARG1 (packet);
int flags;
Notify *n;
TCHAR *name, *p, *partname;
TRACE((_T("ACTION_ADD_NOTIFY\n")));
name = my_strdup (char1 (get_long (nr + 4)));
flags = get_long (nr + 12);
if (!(flags & (NRF_SEND_MESSAGE | NRF_SEND_SIGNAL))) {
PUT_PCK_RES1 (packet, DOS_FALSE);
PUT_PCK_RES2 (packet, ERROR_BAD_NUMBER);
return;
}
#if 0
write_log (_T("Notify:\n"));
write_log (_T("nr_Name '%s'\n"), char1 (get_long (nr + 0)));
write_log (_T("nr_FullName '%s'\n"), name);
write_log (_T("nr_UserData %08X\n"), get_long (nr + 8));
write_log (_T("nr_Flags %08X\n"), flags);
if (flags & NRF_SEND_MESSAGE) {
write_log (_T("Message NotifyRequest, port = %08X\n"), get_long (nr + 16));
} else if (flags & NRF_SEND_SIGNAL) {
write_log (_T("Signal NotifyRequest, Task = %08X signal = %d\n"), get_long (nr + 16), get_long (nr + 20));
} else {
write_log (_T("corrupt NotifyRequest\n"));
}
#endif
p = name + _tcslen (name) - 1;
if (p[0] == ':')
p--;
while (p > name && p[0] != ':' && p[0] != '/')
p--;
if (p[0] == ':' || p[0] == '/')
p++;
partname = my_strdup (p);
n = new_notify (unit, partname);
n->notifyrequest = nr;
n->fullname = name;
if (flags & NRF_NOTIFY_INITIAL) {
int err;
a_inode *a = find_aino (unit, 0, n->fullname, &err);
if (err == 0)
notify_send (unit, n);
}
PUT_PCK_RES1 (packet, DOS_TRUE);
}
static void
action_remove_notify (Unit *unit, dpacket packet)
{
uaecptr nr = GET_PCK_ARG1 (packet);
Notify *n;
int hash;
TRACE((_T("ACTION_REMOVE_NOTIFY\n")));
for (hash = 0; hash < NOTIFY_HASH_SIZE; hash++) {
for (n = unit->notifyhash[hash]; n; n = n->next) {
if (n->notifyrequest == nr) {
//write_log (_T("NotifyRequest %08X freed\n"), n->notifyrequest);
xfree (n->fullname);
xfree (n->partname);
free_notify (unit, hash, n);
PUT_PCK_RES1 (packet, DOS_TRUE);
return;
}
}
}
write_log (_T("Tried to free non-existing NotifyRequest %08X\n"), nr);
PUT_PCK_RES1 (packet, DOS_TRUE);
}
static void free_lock (Unit *unit, uaecptr lock)
{
if (! lock)
return;
if (lock == get_long (unit->volume + 28) << 2) {
put_long (unit->volume + 28, get_long (lock));
} else {
uaecptr current = get_long (unit->volume + 28);
uaecptr next = 0;
while (current) {
next = get_long (current << 2);
if (lock == next << 2)
break;
current = next;
}
if (!current) {
write_log (_T("tried to unlock non-existing lock %x\n"), lock);
return;
}
put_long (current << 2, get_long (lock));
}
lock -= 4;
put_long (lock, get_long (unit->locklist));
put_long (unit->locklist, lock);
}
static void
action_lock (Unit *unit, dpacket packet)
{
uaecptr lock = GET_PCK_ARG1 (packet) << 2;
uaecptr name = GET_PCK_ARG2 (packet) << 2;
long mode = GET_PCK_ARG3 (packet);
a_inode *a;
int err;
if (mode != SHARED_LOCK && mode != EXCLUSIVE_LOCK) {
TRACE((_T("Bad mode %d (should be %d or %d).\n"), mode, SHARED_LOCK, EXCLUSIVE_LOCK));
mode = SHARED_LOCK;
}
TRACE((_T("ACTION_LOCK(0x%08x, \"%s\", %d)\n"), lock, bstr (unit, name), mode));
DUMPLOCK(unit, lock);
a = find_aino (unit, lock, bstr (unit, name), &err);
if (err == 0 && a->softlink) {
err = test_softlink (a);
}
if (err == 0 && (a->elock || (mode != SHARED_LOCK && a->shlock > 0))) {
err = ERROR_OBJECT_IN_USE;
}
/* Lock() doesn't do access checks. */
if (err != 0) {
PUT_PCK_RES1 (packet, DOS_FALSE);
PUT_PCK_RES2 (packet, err);
return;
}
if (mode == SHARED_LOCK)
a->shlock++;
else
a->elock = 1;
de_recycle_aino (unit, a);
PUT_PCK_RES1 (packet, make_lock (unit, a->uniq, mode) >> 2);
}
static void action_read_link_add_parent (Unit *u, a_inode *a, TCHAR *path)
{
if (a == NULL)
return;
action_read_link_add_parent(u, a->parent, path);
if (a == &u->rootnode) {
_tcscat (path, a->aname);
_tcscat (path, _T(":"));
} else {
if (path[0] && path[_tcslen (path) - 1] != ':')
_tcscat (path, _T("/"));
_tcscat (path, a->aname);
}
}
#define LINK_HARD 0
#define LINK_SOFT 1
static void action_make_link (Unit *unit, dpacket packet)
{
uaecptr lock = GET_PCK_ARG1 (packet) << 2;
uaecptr name = GET_PCK_ARG2 (packet) << 2;
uaecptr target = GET_PCK_ARG3 (packet);
int type = GET_PCK_ARG4 (packet);
a_inode *a1, *a2;
int err;
TCHAR tmp[256], tmp2[MAX_DPATH], tmp3[MAX_DPATH];
_tcscpy (tmp, bstr (unit, name));
a1 = aino_from_lock (unit, lock);
if (type == LINK_HARD) {
// we don't support hard links
uaecptr tlock = target << 2;
a2 = aino_from_lock (unit, tlock);
write_log (_T("ACTION_MAKE_LINK(HARD,'%s','%s','%s')\n"),
a1 ? a1->aname : _T("?"), tmp,
a2 ? a2->aname : _T("?"));
PUT_PCK_RES1 (packet, DOS_FALSE);
PUT_PCK_RES2 (packet, ERROR_NOT_IMPLEMENTED);
} else {
a_inode *a3;
TCHAR *link = cstr (unit, target);
write_log (_T("ACTION_MAKE_LINK(SOFT,'%s','%s','%s')\n"),
a1 ? a1->aname : _T("?"), tmp, link);
if (!a1) {
PUT_PCK_RES1 (packet, DOS_FALSE);
PUT_PCK_RES2 (packet, ERROR_OBJECT_NOT_AROUND);
return;
}
// try to find softlink target
for (Unit *u = units; u; u = u->next) {
if (u->volflags & (MYVOLUMEINFO_ARCHIVE | MYVOLUMEINFO_CDFS))
continue;
a3 = find_aino (u, NULL, link, &err);
if (err || !a3)
continue;
_tcscpy (tmp2, a1->nname);
_tcscat (tmp2, FSDB_DIR_SEPARATOR_S);
_tcscat (tmp2, tmp);
tmp3[0] = 0;
action_read_link_add_parent (u, a3, tmp3);
if (!my_createshortcut (tmp2, a3->nname, tmp3)) {
PUT_PCK_RES1 (packet, DOS_FALSE);
PUT_PCK_RES2 (packet, dos_errno ());
}
return;
}
// real Amiga softlinks would accept invalid paths too, we won't.
PUT_PCK_RES1 (packet, DOS_FALSE);
PUT_PCK_RES2 (packet, ERROR_OBJECT_NOT_AROUND);
}
}
static void action_read_link (Unit *unit, dpacket packet)
{
uaecptr lock = GET_PCK_ARG1 (packet) << 2;
uaecptr name = GET_PCK_ARG2 (packet);
uaecptr newname = GET_PCK_ARG3 (packet);
int size = GET_PCK_ARG4 (packet);
a_inode *a, *matched_aino;
Unit *u = NULL, *u2 = NULL, *matched_unit;
int err, i, matched_len;
TCHAR tmp[MAX_DPATH];
TCHAR *namep, *extrapath;
extrapath = NULL;
namep = cstr (unit, name);
for (;;) {
a = find_aino (unit, lock, namep, &err);
if (err != ERROR_IS_SOFT_LINK)
break;
for (i = _tcslen (namep) - 1; i > 0; i--) {
if (namep[i] == '/') {
namep[i] = 0;
xfree (extrapath);
extrapath = my_strdup (namep + i + 1);
break;
}
}
}
if (!a->softlink)
err = ERROR_OBJECT_WRONG_TYPE;
if (err != 0) {
xfree(extrapath);
PUT_PCK_RES1 (packet, DOS_FALSE);
PUT_PCK_RES2 (packet, err);
return;
}
_tcscpy (tmp, a->nname);
write_log (_T("Resolving softlink '%s'\n"), tmp);
if (!my_resolvesoftlink (tmp, sizeof tmp / sizeof (TCHAR))) {
xfree(extrapath);
PUT_PCK_RES1 (packet, DOS_FALSE);
// not sure what to return
PUT_PCK_RES2 (packet, ERROR_OBJECT_NOT_AROUND);
return;
}
write_log (_T("-> '%s'\n"), tmp);
matched_aino = NULL;
matched_unit = NULL;
err = 0;
matched_len = 0;
for (u = units; u; u = u->next) {
if (!(u->volflags & (MYVOLUMEINFO_ARCHIVE | MYVOLUMEINFO_CDFS))) {
TCHAR path[MAX_DPATH];
i = my_issamevolume (u->rootnode.nname, tmp, path);
if (i > matched_len) {
a = find_aino (u, 0, path, &err);
if (a && !err) {
write_log (_T("Match found from '%s' (%d)\n"), u->rootnode.aname, i);
matched_aino = a;
matched_unit = u;
matched_len = i;
}
}
}
}
if (!matched_aino) {
xfree(extrapath);
write_log (_T("Path not found in any mounted drive\n"));
PUT_PCK_RES1 (packet, DOS_FALSE);
PUT_PCK_RES2 (packet, ERROR_OBJECT_NOT_AROUND);
return;
}
tmp[0] = 0;
action_read_link_add_parent (matched_unit, matched_aino, tmp);
if (extrapath) {
_tcscat (tmp, _T("/"));
_tcscat (tmp, extrapath);
}
xfree (extrapath);
write_log (_T("got target '%s'\n"), tmp);
char *s = ua_fs (tmp, -1);
for (i = 0; s[i]; i++) {
if (i >= size - 1)
break;
put_byte (newname + i, s[i]);
}
xfree (s);
put_byte (newname + i, 0);
}
static void action_free_lock (Unit *unit, dpacket packet)
{
uaecptr lock = GET_PCK_ARG1 (packet) << 2;
a_inode *a;
TRACE((_T("ACTION_FREE_LOCK(0x%lx)\n"), lock));
DUMPLOCK(unit, lock);
a = aino_from_lock (unit, lock);
if (a == 0) {
PUT_PCK_RES1 (packet, DOS_FALSE);
PUT_PCK_RES2 (packet, ERROR_OBJECT_NOT_AROUND);
return;
}
if (a->elock)
a->elock = 0;
else
a->shlock--;
recycle_aino (unit, a);
free_lock(unit, lock);
PUT_PCK_RES1 (packet, DOS_TRUE);
}
static uaecptr
action_dup_lock_2 (Unit *unit, dpacket packet, uae_u32 uniq)
{
uaecptr out;
a_inode *a;
a = lookup_aino (unit, uniq);
if (a == 0) {
PUT_PCK_RES1 (packet, DOS_FALSE);
PUT_PCK_RES2 (packet, ERROR_OBJECT_NOT_AROUND);
return 0;
}
/* DupLock()ing exclusive locks isn't possible, says the Autodoc, but
* at least the RAM-Handler seems to allow it. Let's see what happens
* if we don't. */
if (a->elock) {
PUT_PCK_RES1 (packet, DOS_FALSE);
PUT_PCK_RES2 (packet, ERROR_OBJECT_IN_USE);
return 0;
}
a->shlock++;
de_recycle_aino (unit, a);
out = make_lock (unit, a->uniq, -2) >> 2;
PUT_PCK_RES1 (packet, out);
return out;
}
static void
action_dup_lock (Unit *unit, dpacket packet)
{
uaecptr lock = GET_PCK_ARG1 (packet) << 2;
TRACE((_T("ACTION_DUP_LOCK(0x%lx)\n"), lock));
if (!lock) {
PUT_PCK_RES1 (packet, 0);
return;
}
action_dup_lock_2 (unit, packet, get_long (lock + 4));
}
static void
action_lock_from_fh (Unit *unit, dpacket packet)
{
Key *k = lookup_key (unit, GET_PCK_ARG1 (packet));
TRACE((_T("ACTION_COPY_DIR_FH(0x%lx,'%s')\n"), GET_PCK_ARG1 (packet), k ? k->aino->aname : _T("<null>")));
if (k == 0) {
PUT_PCK_RES1 (packet, DOS_FALSE);
return;
}
action_dup_lock_2 (unit, packet, k->aino->uniq);
}
static void free_exkey (Unit *unit, a_inode *aino)
{
if (--aino->exnext_count == 0) {
TRACE ((_T("Freeing ExKey and reducing total_locked from %d by %d\n"),
unit->total_locked_ainos, aino->locked_children));
unit->total_locked_ainos -= aino->locked_children;
aino->locked_children = 0;
}
}
static void move_exkeys (Unit *unit, a_inode *from, a_inode *to)
{
to->exnext_count = from->exnext_count;
to->locked_children = from->locked_children;
from->exnext_count = 0;
from->locked_children = 0;
}
static bool get_statinfo(Unit *unit, a_inode *aino, struct mystat *statbuf)
{
bool ok = true;
memset (statbuf, 0, sizeof statbuf);
/* No error checks - this had better work. */
if (unit->volflags & MYVOLUMEINFO_ARCHIVE)
ok = zfile_stat_archive (aino->nname, statbuf) != 0;
else if (unit->volflags & MYVOLUMEINFO_CDFS)
ok = isofs_stat (unit->ui.cdfs_superblock, aino->uniq_external, statbuf);
else
my_stat (aino->nname, statbuf);
return ok;
}
static void
get_fileinfo (Unit *unit, dpacket packet, uaecptr info, a_inode *aino, bool longfilesize)
{
struct mystat statbuf;
int days, mins, ticks;
int i, n, entrytype, blocksize;
uae_s64 numblocks;
int fsdb_can = fsdb_cando (unit);
TCHAR *xs;
char *x, *x2;
if (aino->vfso) {
fsdb_can = 1;
statbuf.mode = aino->vfso->amigaos_mode;
statbuf.mtime.tv_sec = 0;
statbuf.mtime.tv_usec = 0;
statbuf.size = aino->vfso->size;
} else if (!get_statinfo(unit, aino, &statbuf)) {
PUT_PCK_RES1 (packet, DOS_FALSE);
PUT_PCK_RES2 (packet, ERROR_NOT_A_DOS_DISK);
return;
}
put_long(info + 0, aino->uniq);
if (aino->parent == 0) {
/* Guru book says ST_ROOT = 1 (root directory, not currently used)
* but some programs really expect 2 from root dir..
*/
entrytype = ST_USERDIR;
xs = unit->ui.volname;
} else {
entrytype = aino->softlink ? ST_SOFTLINK : (aino->dir ? ST_USERDIR : ST_FILE);
xs = aino->aname;
}
put_long (info + 4, entrytype);
/* AmigaOS docs say these have to contain the same value. */
put_long (info + 120, entrytype);
TRACE((_T("name=\"%s\"\n"), xs));
x2 = x = ua_fs (xs, -1);
n = strlen (x);
if (n > 107)
n = 107;
if (n > abs (currprefs.filesys_max_name))
n = abs (currprefs.filesys_max_name);
i = 8;
put_byte (info + i, n); i++;
while (n--)
put_byte (info + i, *x), i++, x++;
while (i < 108)
put_byte (info + i, 0), i++;
xfree (x2);
put_long (info + 116, fsdb_can ? aino->amigaos_mode : fsdb_mode_supported (aino));
if (kickstart_version >= 36) {
put_word (info + 224, 0); // OwnerUID
put_word (info + 226, 0); // OwnerGID
}
blocksize = (unit->volflags & MYVOLUMEINFO_CDFS) ? 2048 : 512;
numblocks = (statbuf.size + blocksize - 1) / blocksize;
put_long (info + 128, numblocks > MAXFILESIZE32 ? MAXFILESIZE32 : numblocks);
if (longfilesize) {
/* MorphOS 64-bit file length support */
put_long (info + 124, statbuf.size > MAXFILESIZE32_2G ? 0 : (uae_u32)statbuf.size);
put_long (info + 228, statbuf.size >> 32);
put_long (info + 232, (uae_u32)statbuf.size);
put_long (info + 236, numblocks >> 32);
put_long (info + 240, (uae_u32)numblocks);
} else {
put_long (info + 124, statbuf.size > MAXFILESIZE32 ? MAXFILESIZE32 : (uae_u32)statbuf.size);
}
timeval_to_amiga (&statbuf.mtime, &days, &mins, &ticks, 50);
put_long (info + 132, days);
put_long (info + 136, mins);
put_long (info + 140, ticks);
if (aino->comment == 0 || !fsdb_can)
put_long (info + 144, 0);
else {
TRACE((_T("comment=\"%s\"\n"), aino->comment));
i = 144;
xs = aino->comment;
if (!xs)
xs= _T("");
x2 = x = ua_fs (xs, -1);
n = strlen (x);
if (n > 78)
n = 78;
put_byte (info + i, n); i++;
while (n--)
put_byte (info + i, *x), i++, x++;
while (i < 224)
put_byte (info + i, 0), i++;
xfree (x2);
}
PUT_PCK_RES1 (packet, DOS_TRUE);
}
int get_native_path (uae_u32 lock, TCHAR *out)
{
int i = 0;
for (i = 0; i < MAX_FILESYSTEM_UNITS; i++) {
if (mountinfo.ui[i].self) {
a_inode *a = aino_from_lock (mountinfo.ui[i].self, lock << 2);
if (a) {
_tcscpy (out, a->nname);
return 0;
}
}
}
return -1;
}
#define REC_EXCLUSIVE 0
#define REC_EXCLUSIVE_IMMED 1
#define REC_SHARED 2
#define REC_SHARED_IMMED 3
static struct lockrecord *new_record (uae_u32 packet, uae_u64 pos, uae_u64 len, uae_u32 mode, uae_u32 timeout, uae_u32 msg)
{
struct lockrecord *lr = xcalloc (struct lockrecord, 1);
lr->packet = packet;
lr->pos = pos;
lr->len = len;
lr->mode = mode;
lr->timeout = timeout * vblank_hz / 50;
lr->msg = msg;
return lr;
}
static bool record_hit (Unit *unit, Key *k, uae_u64 pos, uae_u64 len, uae_u32 mode)
{
bool exclusive = mode == REC_EXCLUSIVE || mode == REC_EXCLUSIVE_IMMED;
for (Key *k2 = unit->keys; k2; k2 = k2->next) {
if (k2->aino->uniq == k->aino->uniq) {
if (k2 == k)
continue;
for (struct lockrecord *lr = k2->record; lr; lr = lr->next) {
bool exclusive2 = lr->mode == REC_EXCLUSIVE || lr->mode == REC_EXCLUSIVE_IMMED;
if (exclusive || exclusive2) {
uae_u64 a1 = pos;
uae_u64 a2 = pos + len;
uae_u64 b1 = lr->pos;
uae_u64 b2 = lr->pos + lr->len;
if (len && lr->len) {
bool hit = (a1 >= b1 && a1 < b2) || (a2 > b1 && a2 < b2) || (b1 >= a1 && b1 < a2) || (b2 > a1 && b2 < a2);
if (hit)
return true;
}
}
}
}
}
return false;
}
static void record_timeout (Unit *unit)
{
bool retry = true;
while (retry) {
retry = false;
struct lockrecord *prev = NULL;
for (struct lockrecord *lr = unit->waitingrecords; lr; lr = lr->next) {
lr->timeout--;
if (lr->timeout == 0) {
Key *k = lookup_key (unit, GET_PCK_ARG1 (lr->packet));
PUT_PCK_RES1 (lr->packet, DOS_FALSE);
PUT_PCK_RES2 (lr->packet, ERROR_LOCK_TIMEOUT);
// mark packet as complete
put_long (lr->msg + 4, 0xfffffffe);
uae_Signal (get_long (unit->volume + 176 - 32), 1 << 13);
if (prev)
prev->next = lr->next;
else
unit->waitingrecords = lr->next;
write_log (_T("queued record timed out '%s',%lld,%lld,%d,%d\n"), k ? k->aino->nname : _T("NULL"), lr->pos, lr->len, lr->mode, lr->timeout);
xfree (lr);
retry = true;
break;
}
prev = lr;
}
}
}
static void record_check_waiting (Unit *unit)
{
bool retry = true;
while (retry) {
retry = false;
struct lockrecord *prev = NULL;
for (struct lockrecord *lr = unit->waitingrecords; lr; lr = lr->next) {
Key *k = lookup_key (unit, GET_PCK_ARG1 (lr->packet));
if (!k || !record_hit (unit, k, lr->pos, lr->len, lr->mode)) {
if (prev)
prev->next = lr->next;
else
unit->waitingrecords = lr->next;
write_log (_T("queued record released '%s',%d,%d,%d,%d\n"), k->aino->nname, lr->pos, lr->len, lr->mode, lr->timeout);
// mark packet as complete
put_long (lr->msg + 4, 0xffffffff);
xfree (lr);
retry = true;
break;
}
prev = lr;
}
}
}
static int action_lock_record (Unit *unit, dpacket packet, uae_u32 msg)
{
Key *k = lookup_key (unit, GET_PCK_ARG1 (packet));
uae_u32 pos = GET_PCK_ARG2 (packet);
uae_u32 len = GET_PCK_ARG3 (packet);
uae_u32 mode = GET_PCK_ARG4 (packet);
uae_u32 timeout = GET_PCK_ARG5 (packet);
bool exclusive = mode == REC_EXCLUSIVE || mode == REC_EXCLUSIVE_IMMED;
write_log (_T("action_lock_record('%s',%d,%d,%d,%d)\n"), k ? k->aino->nname : _T("null"), pos, len, mode, timeout);
if (!k || mode > REC_SHARED_IMMED) {
PUT_PCK_RES1 (packet, DOS_FALSE);
PUT_PCK_RES2 (packet, ERROR_OBJECT_WRONG_TYPE);
return 1;
}
if (mode == REC_EXCLUSIVE_IMMED || mode == REC_SHARED_IMMED)
timeout = 0;
if (record_hit (unit, k, pos, len, mode)) {
if (timeout && msg) {
// queue it and do not reply
struct lockrecord *lr = new_record (packet, pos, len, mode, timeout, msg);
if (unit->waitingrecords) {
lr->next = unit->waitingrecords;
unit->waitingrecords = lr;
} else {
unit->waitingrecords = lr;
}
write_log (_T("-> collision, timeout queued\n"));
return -1;
}
PUT_PCK_RES1 (packet, DOS_FALSE);
PUT_PCK_RES2 (packet, ERROR_LOCK_COLLISION);
write_log (_T("-> ERROR_LOCK_COLLISION\n"));
return 1;
}
struct lockrecord *lr = new_record (GET_PCK_ARG1 (packet), pos, len, mode, timeout, 0);
if (k->record) {
lr->next = k->record;
k->record = lr;
} else {
k->record = lr;
}
PUT_PCK_RES1 (packet, DOS_TRUE);
write_log (_T("-> OK\n"));
return 1;
}
static void action_free_record (Unit *unit, dpacket packet)
{
Key *k = lookup_key (unit, GET_PCK_ARG1 (packet));
uae_u32 pos = GET_PCK_ARG2 (packet);
uae_u32 len = GET_PCK_ARG3 (packet);
write_log (_T("action_free_record('%s',%d,%d)\n"), k ? k->aino->nname : _T("null"), pos, len);
if (!k) {
PUT_PCK_RES1 (packet, DOS_FALSE);
PUT_PCK_RES2 (packet, ERROR_OBJECT_WRONG_TYPE);
return;
}
struct lockrecord *prev = NULL;
for (struct lockrecord *lr = k->record; lr; lr = lr->next) {
if (lr->pos == pos && lr->len == len) {
if (prev)
prev->next = lr->next;
else
k->record = lr->next;
xfree (lr);
write_log (_T("->OK\n"));
record_check_waiting (unit);
PUT_PCK_RES1 (packet, DOS_TRUE);
return;
}
}
write_log (_T("-> ERROR_RECORD_NOT_LOCKED\n"));
PUT_PCK_RES1 (packet, DOS_FALSE);
PUT_PCK_RES2 (packet, ERROR_RECORD_NOT_LOCKED);
}
#define EXALL_DEBUG 0
#define EXALL_END 0xde1111ad
static ExAllKey *getexall (Unit *unit, uaecptr control, int id)
{
int i;
if (id < 0) {
for (i = 0; i < EXALLKEYS; i++) {
if (unit->exalls[i].id == 0) {
unit->exallid++;
if (unit->exallid == EXALL_END)
unit->exallid++;
unit->exalls[i].id = unit->exallid;
unit->exalls[i].control = control;
return &unit->exalls[i];
}
}
} else if (id > 0) {
for (i = 0; i < EXALLKEYS; i++) {
if (unit->exalls[i].id == id)
return &unit->exalls[i];
}
}
return NULL;
}
static int exalldo (uaecptr exalldata, uae_u32 exalldatasize, uae_u32 type, uaecptr control, Unit *unit, a_inode *aino)
{
uaecptr exp = exalldata;
int i;
int size, size2;
int entrytype;
TCHAR *xs = NULL, *commentx = NULL;
uae_u32 flags = 15;
int days, mins, ticks;
struct mystat statbuf;
int fsdb_can = fsdb_cando (unit);
uae_u16 uid = 0, gid = 0;
char *x = NULL, *comment = NULL;
int ret = 0;
memset (&statbuf, 0, sizeof statbuf);
if (unit->volflags & MYVOLUMEINFO_ARCHIVE)
zfile_stat_archive (aino->nname, &statbuf);
else if (unit->volflags & MYVOLUMEINFO_CDFS)
isofs_stat (unit->ui.cdfs_superblock, aino->uniq_external, &statbuf);
else
my_stat (aino->nname, &statbuf);
if (aino->parent == 0) {
entrytype = ST_USERDIR;
xs = unit->ui.volname;
} else {
entrytype = aino->softlink ? ST_SOFTLINK : (aino->dir ? ST_USERDIR : ST_FILE);
xs = aino->aname;
}
x = ua_fs (xs, -1);
size = 0;
size2 = 4;
if (type >= 1) {
size2 += 4;
size += strlen (x) + 1;
size = (size + 3) & ~3;
}
if (type >= 2)
size2 += 4;
if (type >= 3)
size2 += 4;
if (type >= 4) {
flags = fsdb_can ? aino->amigaos_mode : fsdb_mode_supported (aino);
size2 += 4;
}
if (type >= 5) {
timeval_to_amiga (&statbuf.mtime, &days, &mins, &ticks, 50);
size2 += 12;
}
if (type >= 6) {
size2 += 4;
if (aino->comment == 0 || !fsdb_can)
commentx = _T("");
else
commentx = aino->comment;
comment = ua_fs (commentx, -1);
size += strlen (comment) + 1;
size = (size + 3) & ~3;
}
if (type >= 7) {
size2 += 4;
uid = 0;
gid = 0;
}
if (type >= 8) {
size2 += 8;
}
i = get_long (control + 0);
while (i > 0) {
exp = get_long (exp); /* ed_Next */
i--;
}
if (exalldata + exalldatasize - exp < size + size2)
goto end; /* not enough space */
#if EXALL_DEBUG > 0
write_log (_T("ID=%d, %d, %08x: '%s'%s\n"),
get_long (control + 4), get_long (control + 0), exp, xs, aino->dir ? _T(" [DIR]") : _T(""));
#endif
put_long (exp, exp + size + size2); /* ed_Next */
if (type >= 1) {
put_long (exp + 4, exp + size2);
for (i = 0; i <= strlen (x); i++) {
put_byte (exp + size2, x[i]);
size2++;
}
}
if (type >= 2)
put_long (exp + 8, entrytype);
if (type >= 3)
put_long (exp + 12, statbuf.size > MAXFILESIZE32 ? MAXFILESIZE32 : statbuf.size);
if (type >= 4)
put_long (exp + 16, flags);
if (type >= 5) {
put_long (exp + 20, days);
put_long (exp + 24, mins);
put_long (exp + 28, ticks);
}
if (type >= 6) {
put_long (exp + 32, exp + size2);
put_byte (exp + size2, strlen (comment));
for (i = 0; i <= strlen (comment); i++) {
put_byte (exp + size2, comment[i]);
size2++;
}
}
if (type >= 7) {
put_word (exp + 36, uid);
put_word (exp + 38, gid);
}
if (type >= 8) {
put_long (exp + 40, statbuf.size >> 32);
put_long (exp + 44, (uae_u32)statbuf.size);
}
put_long (control + 0, get_long (control + 0) + 1);
ret = 1;
end:
xfree (x);
xfree (comment);
return ret;
}
static bool filesys_name_invalid (const TCHAR *fn)
{
return _tcslen (fn) > currprefs.filesys_max_name;
}
static int filesys_readdir(struct fs_dirhandle *d, TCHAR *fn, uae_u64 *uniq)
{
int ok = 0;
if (d->fstype == FS_ARCHIVE)
ok = zfile_readdir_archive(d->zd, fn);
else if (d->fstype == FS_DIRECTORY)
ok = my_readdir(d->od, fn);
else if (d->fstype == FS_CDFS)
ok = isofs_readdir(d->isod, fn, uniq);
return ok;
}
static int action_examine_all_do (Unit *unit, uaecptr lock, ExAllKey *eak, uaecptr exalldata, uae_u32 exalldatasize, uae_u32 type, uaecptr control)
{
a_inode *aino, *base = NULL;
int ok;
uae_u32 err;
struct fs_dirhandle *d;
TCHAR fn[MAX_DPATH];
if (lock != 0)
base = aino_from_lock (unit, lock);
if (base == 0)
base = &unit->rootnode;
for (;;) {
uae_u64 uniq = 0;
d = eak->dirhandle;
if (!eak->fn) {
do {
ok = filesys_readdir(d, fn, &uniq);
} while (ok && d->fstype == FS_DIRECTORY && (filesys_name_invalid (fn) || fsdb_name_invalid_dir (fn)));
if (!ok)
return 0;
} else {
_tcscpy (fn, eak->fn);
xfree (eak->fn);
eak->fn = NULL;
}
aino = lookup_child_aino_for_exnext (unit, base, fn, &err, uniq, NULL);
if (!aino)
return 0;
eak->id = unit->exallid++;
put_long (control + 4, eak->id);
if (!exalldo (exalldata, exalldatasize, type, control, unit, aino)) {
eak->fn = my_strdup (fn); /* no space in exallstruct, save current entry */
break;
}
}
return 1;
}
static int action_examine_all_end (Unit *unit, dpacket packet)
{
uae_u32 id;
uae_u32 doserr = 0;
ExAllKey *eak;
uaecptr control = GET_PCK_ARG5 (packet);
if (kickstart_version < 36)
return 0;
id = get_long (control + 4);
eak = getexall (unit, control, id);
#if EXALL_DEBUG > 0
write_log (_T("EXALL_END ID=%d %x\n"), id, eak);
#endif
if (!eak) {
write_log (_T("FILESYS: EXALL_END non-existing ID %d\n"), id);
doserr = ERROR_OBJECT_WRONG_TYPE;
} else {
eak->id = 0;
fs_closedir (eak->dirhandle);
xfree (eak->fn);
eak->fn = NULL;
eak->dirhandle = NULL;
}
if (doserr) {
PUT_PCK_RES1 (packet, DOS_FALSE);
PUT_PCK_RES2 (packet, doserr);
} else {
PUT_PCK_RES1 (packet, DOS_TRUE);
}
return 1;
}
static int action_examine_all (Unit *unit, dpacket packet)
{
uaecptr lock = GET_PCK_ARG1 (packet) << 2;
uaecptr exalldata = GET_PCK_ARG2 (packet);
uae_u32 exalldatasize = GET_PCK_ARG3 (packet);
uae_u32 type = GET_PCK_ARG4 (packet);
uaecptr control = GET_PCK_ARG5 (packet);
ExAllKey *eak = NULL;
a_inode *base = NULL;
struct fs_dirhandle *d;
int ok, i;
uaecptr exp;
uae_u32 id, doserr = ERROR_NO_MORE_ENTRIES;
ok = 0;
#if EXALL_DEBUG > 0
write_log (_T("exall: %08x %08x-%08x %d %d %08x\n"),
lock, exalldata, exalldata + exalldatasize, exalldatasize, type, control);
write_log (_T("exall: MatchString %08x, MatchFunc %08x\n"),
get_long (control + 8), get_long (control + 12));
#endif
put_long (control + 0, 0); /* eac_Entries */
/* EXAMINE ALL might use dos.library MatchPatternNoCase() which is >=36 */
if (kickstart_version < 36)
return 0;
if (type == 0 || type > 8) {
doserr = ERROR_BAD_NUMBER;
goto fail;
}
PUT_PCK_RES1 (packet, DOS_TRUE);
id = get_long (control + 4);
if (id == EXALL_END) {
write_log (_T("FILESYS: EXALL called twice with ERROR_NO_MORE_ENTRIES\n"));
goto fail; /* already ended exall() */
}
if (id) {
eak = getexall (unit, control, id);
if (!eak) {
write_log (_T("FILESYS: EXALL non-existing ID %d\n"), id);
doserr = ERROR_OBJECT_WRONG_TYPE;
goto fail;
}
if (!action_examine_all_do (unit, lock, eak, exalldata, exalldatasize, type, control))
goto fail;
if (get_long (control + 0) == 0) {
/* uh, no space for first entry.. */
doserr = ERROR_NO_FREE_STORE;
goto fail;
}
} else {
eak = getexall (unit, control, -1);
if (!eak)
goto fail;
if (lock != 0)
base = aino_from_lock (unit, lock);
if (base == 0)
base = &unit->rootnode;
#if EXALL_DEBUG > 0
write_log("exall: ID=%d '%s'\n", eak->id, base->nname);
#endif
d = fs_opendir (unit, base);
if (!d)
goto fail;
eak->dirhandle = d;
put_long (control + 4, eak->id);
if (!action_examine_all_do (unit, lock, eak, exalldata, exalldatasize, type, control))
goto fail;
if (get_long (control + 0) == 0) {
/* uh, no space for first entry.. */
doserr = ERROR_NO_FREE_STORE;
goto fail;
}
}
ok = 1;
fail:
/* Clear last ed_Next. This "list" is quite non-Amiga like.. */
exp = exalldata;
i = get_long (control + 0);
for (;;) {
if (i <= 1) {
if (exp)
put_long (exp, 0);
break;
}
exp = get_long (exp); /* ed_Next */
i--;
}
#if EXALL_DEBUG > 0
write_log("ok=%d, err=%d, eac_Entries = %d\n", ok, ok ? -1 : doserr, get_long (control + 0));
#endif
if (!ok) {
PUT_PCK_RES1 (packet, DOS_FALSE);
PUT_PCK_RES2 (packet, doserr);
if (eak) {
eak->id = 0;
fs_closedir (eak->dirhandle);
eak->dirhandle = NULL;
xfree (eak->fn);
eak->fn = NULL;
}
if (doserr == ERROR_NO_MORE_ENTRIES)
put_long (control + 4, EXALL_END);
}
return 1;
}
static uae_u32 exall_helpder (TrapContext *context)
{
int i;
Unit *u;
uaecptr packet = m68k_areg (regs, 4);
uaecptr control = get_long (packet + dp_Arg5);
uae_u32 id = get_long (control + 4);
#if EXALL_DEBUG > 0
write_log (_T("FILESYS: EXALL extra round ID=%d\n"), id);
#endif
if (id == EXALL_END)
return 1;
for (u = units; u; u = u->next) {
for (i = 0; i < EXALLKEYS; i++) {
if (u->exalls[i].id == id && u->exalls[i].control == control) {
action_examine_all (u, packet);
}
}
}
return 1;
}
static uae_u32 REGPARAM2 fsmisc_helper (TrapContext *context)
{
int mode = m68k_dreg (regs, 0);
switch (mode)
{
case 0:
return exall_helpder (context);
case 1:
return filesys_media_change_reply (context, 0);
case 2:
return filesys_media_change_reply (context, 1);
case 3:
uae_u32 t = getlocaltime ();
uae_u32 secs = (uae_u32)t - (8 * 365 + 2) * 24 * 60 * 60;
return secs;
}
return 0;
}
static void action_examine_object (Unit *unit, dpacket packet)
{
uaecptr lock = GET_PCK_ARG1 (packet) << 2;
uaecptr info = GET_PCK_ARG2 (packet) << 2;
a_inode *aino = 0;
TRACE((_T("ACTION_EXAMINE_OBJECT(0x%lx,0x%lx)\n"), lock, info));
DUMPLOCK(unit, lock);
if (lock != 0)
aino = aino_from_lock (unit, lock);
if (aino == 0)
aino = &unit->rootnode;
get_fileinfo (unit, packet, info, aino, false);
}
extern unsigned char def_tool[];
extern unsigned int def_tool_len;
extern unsigned char def_project[];
extern unsigned int def_project_len;
extern unsigned char def_drawer[];
extern unsigned int def_drawer_len;
static struct virtualfilesysobject vfso_icon_tool;
static struct virtualfilesysobject vfso_icon_project;
static struct virtualfilesysobject vfso_icon_drawer;
static void load_injected_icon(struct virtualfilesysobject *vfso, const TCHAR *fn, uae_u8 *default_data, int default_size)
{
uae_u8 *data = NULL;
int size;
xfree(vfso->data);
if (fn && fn[0])
data = zfile_load_file(fn, &size);
if (!data) {
vfso->data = xmalloc(uae_u8, default_size);
memcpy(vfso->data, default_data, default_size);
vfso->size = default_size;
return;
}
vfso->data = data;
vfso->size = size;
}
static void load_injected_icons(void)
{
load_injected_icon(&vfso_icon_tool, currprefs.filesys_inject_icons_tool, def_tool, def_tool_len);
load_injected_icon(&vfso_icon_project, currprefs.filesys_inject_icons_project, def_project, def_project_len);
load_injected_icon(&vfso_icon_drawer, currprefs.filesys_inject_icons_drawer, def_drawer, def_drawer_len);
}
static void inject_icons_to_directory(Unit *unit, a_inode *base)
{
for (a_inode *aino = base->child; aino; aino = aino->sibling) {
int len = _tcslen(aino->aname);
if (len >= 5 && !_tcsicmp(aino->aname + len - 5, _T(".info")))
continue;
TCHAR tmp[256];
_stprintf(tmp, _T("%s.info"), aino->aname);
bool match = false;
for (a_inode *aino2 = base->child; aino2; aino2 = aino2->sibling) {
if (!_tcsicmp(aino2->aname, tmp))
match = true;
}
if (match)
continue;
uae_u32 err;
struct virtualfilesysobject *vfso;
if (aino->dir) {
vfso = &vfso_icon_drawer;
} else {
if (aino->amigaos_mode & A_FIBF_EXECUTE)
vfso = &vfso_icon_project;
else
vfso = &vfso_icon_tool;
}
lookup_child_aino_for_exnext(unit, base, tmp, &err, 0, vfso);
}
}
/* Read a directory's contents, create a_inodes for each file, and
mark them as locked in memory so that recycle_aino will not reap
them.
We do this to avoid problems with the host OS: we don't want to
leave the directory open on the host side until all ExNext()s have
finished - they may never finish! */
static void populate_directory (Unit *unit, a_inode *base)
{
struct fs_dirhandle *d;
a_inode *aino;
d = fs_opendir (unit, base);
if (!d)
return;
for (aino = base->child; aino; aino = aino->sibling) {
base->locked_children++;
unit->total_locked_ainos++;
}
TRACE3((_T("Populating directory, child %s, locked_children %d\n"),
base->child->nname, base->locked_children));
for (;;) {
uae_u64 uniq = 0;
TCHAR fn[MAX_DPATH];
int ok;
uae_u32 err;
/* Find next file that belongs to the Amiga fs (skipping things
like "..", "." etc. */
do {
ok = filesys_readdir(d, fn, &uniq);
} while (ok && d->fstype == FS_DIRECTORY && (filesys_name_invalid (fn) || fsdb_name_invalid_dir (fn)));
if (!ok)
break;
/* This calls init_child_aino, which will notice that the parent is
being ExNext()ed, and it will increment the locked counts. */
aino = lookup_child_aino_for_exnext (unit, base, fn, &err, uniq, NULL);
}
fs_closedir (d);
if (currprefs.filesys_inject_icons || unit->ui.inject_icons)
inject_icons_to_directory(unit, base);
}
static bool do_examine (Unit *unit, dpacket packet, a_inode *aino, uaecptr info, bool longfilesize)
{
for (;;) {
TCHAR *name;
if (!aino)
break;
name = aino->nname;
get_fileinfo (unit, packet, info, aino, longfilesize);
if (!aino->vfso && !(unit->volflags & (MYVOLUMEINFO_ARCHIVE | MYVOLUMEINFO_CDFS)) && !fsdb_exists(name)) {
TRACE ((_T("%s orphaned"), name));
return false;
}
return true;
}
TRACE((_T("no more entries\n")));
free_exkey (unit, aino->parent);
PUT_PCK_RES1 (packet, DOS_FALSE);
PUT_PCK_RES2 (packet, ERROR_NO_MORE_ENTRIES);
return true;
}
#define EXNEXT_DEBUG 0
static void action_examine_next (Unit *unit, dpacket packet, bool largefilesize)
{
uaecptr lock = GET_PCK_ARG1 (packet) << 2;
uaecptr info = GET_PCK_ARG2 (packet) << 2;
a_inode *aino = 0, *daino = 0;
uae_u32 uniq;
TRACE((_T("ACTION_EXAMINE_NEXT(0x%lx,0x%lx,%d)\n"), lock, info, largefilesize));
gui_flicker_led (UNIT_LED(unit), unit->unit, 1);
DUMPLOCK(unit, lock);
if (lock != 0)
aino = aino_from_lock (unit, lock);
if (aino == 0)
aino = &unit->rootnode;
uniq = get_long(info);
for (;;) {
if (uniq == aino->uniq) {
// first exnext
if (!aino->dir) {
write_log (_T("ExNext called for a file! %s:%d (Houston?)\n"), aino->nname, uniq);
goto no_more_entries;
}
if (aino->exnext_count++ == 0)
populate_directory (unit, aino);
if (!aino->child)
goto no_more_entries;
daino = aino->child;
} else {
daino = lookup_aino(unit, uniq);
if (!daino) {
#if EXNEXT_DEBUG
write_log(_T("EXNEXT but next entry is missing! (%d)\n"), uniq);
#endif
// deleted? Look for next larger uniq in same directory.
daino = aino->child;
while (daino && uniq >= daino->uniq) {
daino = daino->sibling;
}
#if EXNEXT_DEBUG
if (daino) {
write_log(_T("Using next found entry %d\n"), uniq);
}
#endif
// didn't find, what about previous?
if (!daino) {
daino = aino->child;
while (daino && uniq >= daino->uniq) {
if (daino->sibling && daino->sibling->uniq >= uniq) {
#if EXNEXT_DEBUG
write_log(_T("Using previous entry %d\n"), uniq);
#endif
break;
}
daino = daino->sibling;
}
}
// didn't find any but there are still entries? restart from beginning.
if (!daino && aino->child) {
daino = aino->child;
#if EXNEXT_DEBUG
write_log(_T("Re-starting from beginning %d\n"), daino->uniq);
#endif
}
} else {
daino = daino->sibling;
}
}
if (!daino)
goto no_more_entries;
if (daino->parent != aino) {
write_log(_T("Houston, we have a BIG problem. %s is not parent of %s\n"), daino->nname, aino->nname);
goto no_more_entries;
}
uniq = daino->uniq;
if (daino->mountcount != unit->mountcount)
continue;
if (!do_examine (unit, packet, daino, info, largefilesize))
continue;
return;
}
no_more_entries:
free_exkey(unit, aino);
PUT_PCK_RES1(packet, DOS_FALSE);
PUT_PCK_RES2 (packet, ERROR_NO_MORE_ENTRIES);
}
static void do_find (Unit *unit, dpacket packet, int mode, int create, int fallback)
{
uaecptr fh = GET_PCK_ARG1 (packet) << 2;
uaecptr lock = GET_PCK_ARG2 (packet) << 2;
uaecptr name = GET_PCK_ARG3 (packet) << 2;
a_inode *aino;
Key *k;
struct fs_filehandle *fd = NULL;
int err;
mode_t openmode;
int aino_created = 0;
int isvirtual = unit->volflags & (MYVOLUMEINFO_ARCHIVE | MYVOLUMEINFO_CDFS);
TRACE((_T("ACTION_FIND_*(0x%08x,0x%08x,\"%s\",%d,%d)\n"), fh, lock, bstr (unit, name), mode, create));
TRACE((_T("fh=%x lock=%x name=%x\n"), fh, lock, name));
DUMPLOCK(unit, lock);
aino = find_aino (unit, lock, bstr (unit, name), &err);
if (aino == 0 || (err != 0 && err != ERROR_OBJECT_NOT_AROUND)) {
/* Whatever it is, we can't handle it. */
PUT_PCK_RES1 (packet, DOS_FALSE);
PUT_PCK_RES2 (packet, err);
return;
}
if (aino->softlink) {
handle_softlink (unit, packet, aino);
return;
}
if (err == 0) {
/* Object exists. */
if (aino->dir) {
PUT_PCK_RES1 (packet, DOS_FALSE);
PUT_PCK_RES2 (packet, ERROR_OBJECT_WRONG_TYPE);
return;
}
if (aino->elock || (create == 2 && aino->shlock > 0)) {
PUT_PCK_RES1 (packet, DOS_FALSE);
PUT_PCK_RES2 (packet, ERROR_OBJECT_IN_USE);
return;
}
if (create && aino->vfso) {
PUT_PCK_RES1 (packet, DOS_FALSE);
PUT_PCK_RES2 (packet, ERROR_DELETE_PROTECTED);
return;
}
if (create == 2 && (aino->amigaos_mode & A_FIBF_DELETE) != 0) {
PUT_PCK_RES1 (packet, DOS_FALSE);
PUT_PCK_RES2 (packet, ERROR_DELETE_PROTECTED);
return;
}
if (create != 2) {
if ((((mode & aino->amigaos_mode) & A_FIBF_WRITE) != 0 || unit->ui.readonly || unit->ui.locked)
&& fallback)
{
mode &= ~A_FIBF_WRITE;
}
/* Kick 1.3 doesn't check read and write access bits - maybe it would be
* simpler just not to do that either. */
if ((mode & A_FIBF_WRITE) != 0 && (unit->ui.readonly || unit->ui.locked)) {
PUT_PCK_RES1 (packet, DOS_FALSE);
PUT_PCK_RES2 (packet, ERROR_DISK_WRITE_PROTECTED);
return;
}
if (((mode & aino->amigaos_mode) & A_FIBF_WRITE) != 0
|| mode == 0)
{
PUT_PCK_RES1 (packet, DOS_FALSE);
PUT_PCK_RES2 (packet, ERROR_WRITE_PROTECTED);
return;
}
if (((mode & aino->amigaos_mode) & A_FIBF_READ) != 0) {
PUT_PCK_RES1 (packet, DOS_FALSE);
PUT_PCK_RES2 (packet, ERROR_READ_PROTECTED);
return;
}
}
} else if (create == 0) {
PUT_PCK_RES1 (packet, DOS_FALSE);
PUT_PCK_RES2 (packet, err);
return;
} else {
/* Object does not exist. aino points to containing directory. */
aino = create_child_aino (unit, aino, my_strdup (bstr_cut (unit, name)), 0);
if (aino == 0) {
PUT_PCK_RES1 (packet, DOS_FALSE);
PUT_PCK_RES2 (packet, ERROR_DISK_IS_FULL); /* best we can do */
return;
}
aino_created = 1;
}
prepare_for_open (aino->nname);
if (!aino->vfso) {
openmode = (((mode & A_FIBF_READ) == 0 ? O_WRONLY
: (mode & A_FIBF_WRITE) == 0 ? O_RDONLY
: O_RDWR)
| (create ? O_CREAT : 0)
| (create == 2 ? O_TRUNC : 0));
fd = fs_openfile (unit, aino, openmode | O_BINARY);
if (fd == NULL) {
if (aino_created)
delete_aino (unit, aino);
PUT_PCK_RES1 (packet, DOS_FALSE);
/* archive and fd == NULL = corrupt archive or out of memory */
PUT_PCK_RES2 (packet, isvirtual ? ERROR_OBJECT_NOT_AROUND : dos_errno ());
return;
}
}
k = new_key (unit);
k->fd = fd;
k->aino = aino;
k->dosmode = mode;
k->createmode = create;
k->notifyactive = create ? 1 : 0;
if (create && isvirtual)
fsdb_set_file_attrs (aino);
put_long (fh + 36, k->uniq);
if (create == 2) {
aino->elock = 1;
// clear comment if file already existed
if (aino->comment) {
xfree (aino->comment);
aino->comment = 0;
}
fsdb_set_file_attrs (aino);
} else {
aino->shlock++;
}
de_recycle_aino (unit, aino);
PUT_PCK_RES1 (packet, DOS_TRUE);
}
static void
action_fh_from_lock (Unit *unit, dpacket packet)
{
uaecptr fh = GET_PCK_ARG1 (packet) << 2;
uaecptr lock = GET_PCK_ARG2 (packet) << 2;
a_inode *aino;
Key *k;
struct fs_filehandle *fd;
mode_t openmode;
int mode;
TRACE((_T("ACTION_FH_FROM_LOCK(0x%lx,0x%lx)\n"), fh, lock));
DUMPLOCK(unit,lock);
if (!lock) {
PUT_PCK_RES1 (packet, DOS_FALSE);
PUT_PCK_RES2 (packet, 0);
return;
}
aino = aino_from_lock (unit, lock);
if (aino == 0)
aino = &unit->rootnode;
if (aino->softlink) {
handle_softlink (unit, packet, aino);
return;
}
mode = aino->amigaos_mode; /* Use same mode for opened filehandle as existing Lock() */
prepare_for_open (aino->nname);
TRACE ((_T(" mode is %d\n"), mode));
openmode = (((mode & A_FIBF_READ) ? O_WRONLY
: (mode & A_FIBF_WRITE) ? O_RDONLY
: O_RDWR));
/* the files on CD really can have the write-bit set. */
if (unit->ui.readonly || unit->ui.locked)
openmode = O_RDONLY;
fd = fs_openfile (unit, aino, openmode | O_BINARY);
if (fd == NULL) {
PUT_PCK_RES1 (packet, DOS_FALSE);
PUT_PCK_RES2 (packet, dos_errno ());
return;
}
k = new_key (unit);
k->fd = fd;
k->aino = aino;
put_long (fh + 36, k->uniq);
/* I don't think I need to play with shlock count here, because I'm
opening from an existing lock ??? */
de_recycle_aino (unit, aino);
free_lock (unit, lock); /* lock must be unlocked */
PUT_PCK_RES1 (packet, DOS_TRUE);
/* PUT_PCK_RES2 (packet, k->uniq); - this shouldn't be necessary, try without it */
}
static void
action_find_input (Unit *unit, dpacket packet)
{
do_find (unit, packet, A_FIBF_READ | A_FIBF_WRITE, 0, 1);
}
static void
action_find_output (Unit *unit, dpacket packet)
{
if (unit->ui.readonly || unit->ui.locked) {
PUT_PCK_RES1 (packet, DOS_FALSE);
PUT_PCK_RES2 (packet, ERROR_DISK_WRITE_PROTECTED);
return;
}
do_find (unit, packet, A_FIBF_READ | A_FIBF_WRITE, 2, 0);
}
static void
action_find_write (Unit *unit, dpacket packet)
{
if (unit->ui.readonly || unit->ui.locked) {
PUT_PCK_RES1 (packet, DOS_FALSE);
PUT_PCK_RES2 (packet, ERROR_DISK_WRITE_PROTECTED);
return;
}
do_find (unit, packet, A_FIBF_READ | A_FIBF_WRITE, 1, 0);
}
/* change file/dir's parent dir modification time */
static void updatedirtime (a_inode *a1, int now)
{
struct mystat statbuf;
if (!a1->parent)
return;
if (!now) {
if (!my_stat (a1->nname, &statbuf))
return;
my_utime (a1->parent->nname, &statbuf.mtime);
} else {
my_utime (a1->parent->nname, NULL);
}
}
static void
action_end (Unit *unit, dpacket packet)
{
Key *k;
TRACE((_T("ACTION_END(0x%lx)\n"), GET_PCK_ARG1 (packet)));
k = lookup_key (unit, GET_PCK_ARG1 (packet));
if (k != 0) {
if (k->notifyactive) {
notify_check (unit, k->aino);
updatedirtime (k->aino, 1);
}
if (k->aino->elock)
k->aino->elock = 0;
else
k->aino->shlock--;
recycle_aino (unit, k->aino);
free_key (unit, k);
}
PUT_PCK_RES1 (packet, DOS_TRUE);
PUT_PCK_RES2 (packet, 0);
}
static void
action_read (Unit *unit, dpacket packet)
{
Key *k = lookup_key (unit, GET_PCK_ARG1 (packet));
uaecptr addr = GET_PCK_ARG2 (packet);
uae_u32 size = GET_PCK_ARG3 (packet);
uae_u32 actual = 0;
if (k == 0) {
PUT_PCK_RES1 (packet, DOS_FALSE);
/* PUT_PCK_RES2 (packet, EINVAL); */
return;
}
TRACE((_T("ACTION_READ(%s,0x%lx,%ld)\n"), k->aino->nname, addr, size));
gui_flicker_led (UNIT_LED(unit), unit->unit, 1);
if (size == 0) {
PUT_PCK_RES1 (packet, 0);
PUT_PCK_RES2 (packet, 0);
} else if (k->aino->vfso) {
uae_s64 filesize = k->aino->vfso->size;
for (int i = 0; i < size && k->file_pos < filesize; i++) {
put_byte(addr + i, k->aino->vfso->data[k->file_pos]);
k->file_pos++;
actual++;
}
PUT_PCK_RES1 (packet, actual);
size = 0;
} else if (!valid_address (addr, size)) {
/* check if filesize < size */
uae_s64 filesize, cur;
filesize = key_filesize(k);
cur = k->file_pos;
if (size > filesize - cur)
size = filesize - cur;
if (size == 0) {
PUT_PCK_RES1 (packet, 0);
PUT_PCK_RES2 (packet, 0);
} else if (!valid_address (addr, size)) {
/* it really crosses memory boundary */
uae_u8 *buf;
write_log (_T("unixfs warning: Bad pointer passed for read: %08x, size %d\n"), addr, size);
/* ugh this is inefficient but easy */
if (key_seek(k, k->file_pos, SEEK_SET) < 0) {
PUT_PCK_RES1 (packet, 0);
PUT_PCK_RES2 (packet, dos_errno ());
return;
}
buf = xmalloc (uae_u8, size);
if (!buf) {
PUT_PCK_RES1 (packet, -1);
PUT_PCK_RES2 (packet, ERROR_NO_FREE_STORE);
return;
}
actual = fs_read (k->fd, buf, size);
if ((uae_s32)actual == -1) {
PUT_PCK_RES1 (packet, 0);
PUT_PCK_RES2 (packet, dos_errno ());
} else {
int i;
PUT_PCK_RES1 (packet, actual);
for (i = 0; i < actual; i++)
put_byte (addr + i, buf[i]);
k->file_pos += actual;
}
xfree (buf);
flush_dcache (addr, size);
size = 0;
}
}
if (size) {
/* normal fast read */
uae_u8 *realpt = get_real_address (addr);
if (key_seek(k, k->file_pos, SEEK_SET) < 0) {
PUT_PCK_RES1 (packet, 0);
PUT_PCK_RES2 (packet, dos_errno ());
return;
}
actual = fs_read (k->fd, realpt, size);
if (actual == 0) {
PUT_PCK_RES1 (packet, 0);
PUT_PCK_RES2 (packet, 0);
} else if (actual < 0) {
PUT_PCK_RES1 (packet, 0);
PUT_PCK_RES2 (packet, dos_errno ());
} else {
PUT_PCK_RES1 (packet, actual);
k->file_pos += actual;
}
flush_dcache (addr, size);
}
TRACE((_T("=%d\n"), actual));
}
static void
action_write (Unit *unit, dpacket packet)
{
Key *k = lookup_key (unit, GET_PCK_ARG1 (packet));
uaecptr addr = GET_PCK_ARG2 (packet);
uae_u32 size = GET_PCK_ARG3 (packet);
uae_u32 actual;
uae_u8 *buf;
int i;
if (k == 0) {
PUT_PCK_RES1 (packet, DOS_FALSE);
/* PUT_PCK_RES2 (packet, EINVAL); */
return;
}
gui_flicker_led (UNIT_LED(unit), unit->unit, 2);
TRACE((_T("ACTION_WRITE(%s,0x%lx,%ld)\n"), k->aino->nname, addr, size));
if (unit->ui.readonly || unit->ui.locked || k->aino->vfso) {
PUT_PCK_RES1 (packet, DOS_FALSE);
PUT_PCK_RES2 (packet, ERROR_DISK_WRITE_PROTECTED);
return;
}
if (size == 0) {
actual = 0;
PUT_PCK_RES1 (packet, 0);
PUT_PCK_RES2 (packet, 0);
} else if (valid_address (addr, size)) {
uae_u8 *realpt = get_real_address (addr);
if (key_seek(k, k->file_pos, SEEK_SET) < 0) {
PUT_PCK_RES1 (packet, 0);
PUT_PCK_RES2 (packet, dos_errno ());
return;
}
actual = fs_write (k->fd, realpt, size);
} else {
write_log (_T("unixfs warning: Bad pointer passed for write: %08x, size %d\n"), addr, size);
/* ugh this is inefficient but easy */
if (key_seek(k, k->file_pos, SEEK_SET) < 0) {
PUT_PCK_RES1 (packet, 0);
PUT_PCK_RES2 (packet, dos_errno ());
return;
}
buf = xmalloc (uae_u8, size);
if (!buf) {
PUT_PCK_RES1 (packet, -1);
PUT_PCK_RES2 (packet, ERROR_NO_FREE_STORE);
return;
}
for (i = 0; i < size; i++)
buf[i] = get_byte (addr + i);
actual = fs_write (k->fd, buf, size);
xfree (buf);
}
TRACE((_T("=%d\n"), actual));
PUT_PCK_RES1 (packet, actual);
if (actual != size)
PUT_PCK_RES2 (packet, dos_errno ());
if ((uae_s32)actual != -1)
k->file_pos += actual;
k->notifyactive = 1;
}
static void
action_seek (Unit *unit, dpacket packet)
{
Key *k = lookup_key (unit, GET_PCK_ARG1 (packet));
long pos = (uae_s32)GET_PCK_ARG2 (packet);
long mode = (uae_s32)GET_PCK_ARG3 (packet);
uae_s64 res;
uae_s64 cur;
int whence = SEEK_CUR;
uae_s64 temppos, filesize;
if (k == 0) {
PUT_PCK_RES1 (packet, -1);
PUT_PCK_RES2 (packet, ERROR_INVALID_LOCK);
return;
}
if (mode > 0)
whence = SEEK_END;
if (mode < 0)
whence = SEEK_SET;
cur = k->file_pos;
TRACE((_T("ACTION_SEEK(%s,%d,%d)=%d\n"), k->aino->nname, pos, mode, cur));
gui_flicker_led (UNIT_LED(unit), unit->unit, 1);
filesize = key_filesize(k);
if (whence == SEEK_CUR)
temppos = cur + pos;
if (whence == SEEK_SET)
temppos = pos;
if (whence == SEEK_END)
temppos = filesize + pos;
if (filesize < temppos || temppos < 0) {
PUT_PCK_RES1 (packet, -1);
PUT_PCK_RES2 (packet, ERROR_SEEK_ERROR);
return;
}
res = key_seek(k, pos, whence);
if (-1 == res || cur > MAXFILESIZE32) {
PUT_PCK_RES1 (packet, -1);
PUT_PCK_RES2 (packet, ERROR_SEEK_ERROR);
key_seek(k, cur, SEEK_SET);
} else {
PUT_PCK_RES1 (packet, cur);
k->file_pos = key_seek(k, 0, SEEK_CUR);
}
}
static void
action_set_protect (Unit *unit, dpacket packet)
{
uaecptr lock = GET_PCK_ARG2 (packet) << 2;
uaecptr name = GET_PCK_ARG3 (packet) << 2;
uae_u32 mask = GET_PCK_ARG4 (packet);
a_inode *a;
int err;
TRACE((_T("ACTION_SET_PROTECT(0x%lx,\"%s\",0x%lx)\n"), lock, bstr (unit, name), mask));
if (unit->ui.readonly || unit->ui.locked) {
PUT_PCK_RES1 (packet, DOS_FALSE);
PUT_PCK_RES2 (packet, ERROR_DISK_WRITE_PROTECTED);
return;
}
a = find_aino (unit, lock, bstr (unit, name), &err);
if (err != 0) {
PUT_PCK_RES1 (packet, DOS_FALSE);
PUT_PCK_RES2 (packet, err);
return;
}
if (a->softlink) {
handle_softlink (unit, packet, a);
return;
}
a->amigaos_mode = mask;
if (!fsdb_cando (unit))
a->amigaos_mode = fsdb_mode_supported (a);
err = fsdb_set_file_attrs (a);
if (err != 0) {
PUT_PCK_RES1 (packet, DOS_FALSE);
PUT_PCK_RES2 (packet, err);
} else {
PUT_PCK_RES1 (packet, DOS_TRUE);
}
notify_check (unit, a);
gui_flicker_led (UNIT_LED(unit), unit->unit, 2);
}
static void action_set_comment (Unit * unit, dpacket packet)
{
uaecptr lock = GET_PCK_ARG2 (packet) << 2;
uaecptr name = GET_PCK_ARG3 (packet) << 2;
uaecptr comment = GET_PCK_ARG4 (packet) << 2;
TCHAR *commented = NULL;
a_inode *a;
int err;
if (unit->ui.readonly || unit->ui.locked) {
PUT_PCK_RES1 (packet, DOS_FALSE);
PUT_PCK_RES2 (packet, ERROR_DISK_WRITE_PROTECTED);
return;
}
if (fsdb_cando (unit)) {
commented = bstr (unit, comment);
if (_tcslen (commented) > 80) {
PUT_PCK_RES1 (packet, DOS_FALSE);
PUT_PCK_RES2 (packet, ERROR_COMMENT_TOO_BIG);
return;
}
if (_tcslen (commented) > 0) {
TCHAR *p = commented;
commented = xmalloc (TCHAR, 81);
_tcsncpy (commented, p, 80);
commented[80] = 0;
} else {
commented = NULL;
}
}
TRACE ((_T("ACTION_SET_COMMENT(0x%lx,\"%s\")\n"), lock, commented));
a = find_aino (unit, lock, bstr (unit, name), &err);
if (err != 0) {
PUT_PCK_RES1 (packet, DOS_FALSE);
PUT_PCK_RES2 (packet, err);
maybe_free_and_out:
if (commented)
xfree (commented);
return;
}
if (a->softlink) {
handle_softlink (unit, packet, a);
goto maybe_free_and_out;
}
PUT_PCK_RES1 (packet, DOS_TRUE);
PUT_PCK_RES2 (packet, 0);
if (a->comment == 0 && commented == 0)
goto maybe_free_and_out;
if (a->comment != 0 && commented != 0 && _tcscmp (a->comment, commented) == 0)
goto maybe_free_and_out;
if (a->comment)
xfree (a->comment);
a->comment = commented;
fsdb_set_file_attrs (a);
notify_check (unit, a);
gui_flicker_led (UNIT_LED(unit), unit->unit, 2);
}
static void
action_same_lock (Unit *unit, dpacket packet)
{
uaecptr lock1 = GET_PCK_ARG1 (packet) << 2;
uaecptr lock2 = GET_PCK_ARG2 (packet) << 2;
TRACE((_T("ACTION_SAME_LOCK(0x%lx,0x%lx)\n"), lock1, lock2));
DUMPLOCK(unit, lock1); DUMPLOCK(unit, lock2);
if (!lock1 || !lock2) {
PUT_PCK_RES1 (packet, lock1 == lock2 ? DOS_TRUE : DOS_FALSE);
} else {
PUT_PCK_RES1 (packet, get_long (lock1 + 4) == get_long (lock2 + 4) ? DOS_TRUE : DOS_FALSE);
}
}
static void
action_change_mode (Unit *unit, dpacket packet)
{
#define CHANGE_LOCK 0
#define CHANGE_FH 1
/* will be CHANGE_FH or CHANGE_LOCK value */
long type = GET_PCK_ARG1 (packet);
/* either a file-handle or lock */
uaecptr object = GET_PCK_ARG2 (packet) << 2;
/* will be EXCLUSIVE_LOCK/SHARED_LOCK if CHANGE_LOCK,
* or MODE_OLDFILE/MODE_NEWFILE/MODE_READWRITE if CHANGE_FH *
* Above is wrong, it is always *_LOCK. TW. */
long mode = GET_PCK_ARG3 (packet);
unsigned long uniq;
a_inode *a = NULL, *olda = NULL;
int err = 0;
TRACE((_T("ACTION_CHANGE_MODE(0x%lx,%d,%d)\n"), object, type, mode));
if (! object || (type != CHANGE_FH && type != CHANGE_LOCK)) {
PUT_PCK_RES1 (packet, DOS_FALSE);
PUT_PCK_RES2 (packet, ERROR_INVALID_LOCK);
return;
}
if (type == CHANGE_LOCK) {
uniq = get_long (object + 4);
} else {
Key *k = lookup_key (unit, get_long (object + 36));
if (!k) {
PUT_PCK_RES1 (packet, DOS_FALSE);
PUT_PCK_RES2 (packet, ERROR_OBJECT_NOT_AROUND);
return;
}
uniq = k->aino->uniq;
}
a = lookup_aino (unit, uniq);
if (! a) {
err = ERROR_INVALID_LOCK;
} else {
if (mode == -1) {
if (a->shlock > 1) {
err = ERROR_OBJECT_IN_USE;
} else {
a->shlock = 0;
a->elock = 1;
}
} else { /* Must be SHARED_LOCK == -2 */
a->elock = 0;
a->shlock++;
}
}
if (err) {
PUT_PCK_RES1 (packet, DOS_FALSE);
PUT_PCK_RES2 (packet, err);
return;
} else {
de_recycle_aino (unit, a);
PUT_PCK_RES1 (packet, DOS_TRUE);
}
}
static void
action_parent_common (Unit *unit, dpacket packet, unsigned long uniq)
{
a_inode *olda = lookup_aino (unit, uniq);
if (olda == 0) {
PUT_PCK_RES1 (packet, DOS_FALSE);
PUT_PCK_RES2 (packet, ERROR_INVALID_LOCK);
return;
}
if (olda->parent == 0) {
PUT_PCK_RES1 (packet, 0);
PUT_PCK_RES2 (packet, 0);
return;
}
if (olda->parent->elock) {
PUT_PCK_RES1 (packet, DOS_FALSE);
PUT_PCK_RES2 (packet, ERROR_OBJECT_IN_USE);
return;
}
olda->parent->shlock++;
de_recycle_aino (unit, olda->parent);
PUT_PCK_RES1 (packet, make_lock (unit, olda->parent->uniq, -2) >> 2);
}
static void
action_parent_fh (Unit *unit, dpacket packet)
{
Key *k = lookup_key (unit, GET_PCK_ARG1 (packet));
if (!k) {
PUT_PCK_RES1 (packet, DOS_FALSE);
PUT_PCK_RES2 (packet, ERROR_OBJECT_NOT_AROUND);
return;
}
action_parent_common (unit, packet, k->aino->uniq);
}
static void
action_parent (Unit *unit, dpacket packet)
{
uaecptr lock = GET_PCK_ARG1 (packet) << 2;
TRACE((_T("ACTION_PARENT(0x%lx)\n"),lock));
if (!lock) {
PUT_PCK_RES1 (packet, 0);
PUT_PCK_RES2 (packet, 0);
} else {
action_parent_common (unit, packet, get_long (lock + 4));
}
TRACE((_T("=%x %d\n"), GET_PCK_RES1 (packet), GET_PCK_RES2 (packet)));
}
static void
action_create_dir (Unit *unit, dpacket packet)
{
uaecptr lock = GET_PCK_ARG1 (packet) << 2;
uaecptr name = GET_PCK_ARG2 (packet) << 2;
a_inode *aino;
int err;
TRACE((_T("ACTION_CREATE_DIR(0x%lx,\"%s\")\n"), lock, bstr (unit, name)));
if (unit->ui.readonly || unit->ui.locked) {
PUT_PCK_RES1 (packet, DOS_FALSE);
PUT_PCK_RES2 (packet, ERROR_DISK_WRITE_PROTECTED);
return;
}
aino = find_aino (unit, lock, bstr (unit, name), &err);
if (aino == 0 || (err != 0 && err != ERROR_OBJECT_NOT_AROUND)) {
PUT_PCK_RES1 (packet, DOS_FALSE);
PUT_PCK_RES2 (packet, err);
return;
}
if (err == 0) {
/* Object exists. */
PUT_PCK_RES1 (packet, DOS_FALSE);
PUT_PCK_RES2 (packet, ERROR_OBJECT_EXISTS);
return;
}
/* Object does not exist. aino points to containing directory. */
aino = create_child_aino (unit, aino, my_strdup (bstr_cut (unit, name)), 1);
if (aino == 0) {
PUT_PCK_RES1 (packet, DOS_FALSE);
PUT_PCK_RES2 (packet, ERROR_DISK_IS_FULL); /* best we can do */
return;
}
if (my_mkdir (aino->nname) == -1) {
PUT_PCK_RES1 (packet, DOS_FALSE);
PUT_PCK_RES2 (packet, dos_errno ());
return;
}
aino->shlock = 1;
fsdb_set_file_attrs (aino);
de_recycle_aino (unit, aino);
notify_check (unit, aino);
updatedirtime (aino, 0);
PUT_PCK_RES1 (packet, make_lock (unit, aino->uniq, -2) >> 2);
gui_flicker_led (UNIT_LED(unit), unit->unit, 2);
}
static void
action_examine_fh (Unit *unit, dpacket packet, bool largefilesize)
{
Key *k;
a_inode *aino = 0;
uaecptr info = GET_PCK_ARG2 (packet) << 2;
TRACE((_T("ACTION_EXAMINE_FH(0x%lx,0x%lx,%d)\n"),
GET_PCK_ARG1 (packet), GET_PCK_ARG2 (packet), largefilesize ));
k = lookup_key (unit, GET_PCK_ARG1 (packet));
if (k != 0)
aino = k->aino;
if (aino == 0)
aino = &unit->rootnode;
get_fileinfo (unit, packet, info, aino, largefilesize);
}
/* For a nice example of just how contradictory documentation can be, see the
* Autodoc for DOS:SetFileSize and the Packets.txt description of this packet...
* This implementation tries to mimic the behaviour of the Kick 3.1 ramdisk
* (which seems to match the Autodoc description). */
static void
action_set_file_size (Unit *unit, dpacket packet)
{
Key *k, *k1;
off_t offset = GET_PCK_ARG2 (packet);
long mode = (uae_s32)GET_PCK_ARG3 (packet);
int whence = SEEK_CUR;
if (mode > 0)
whence = SEEK_END;
if (mode < 0)
whence = SEEK_SET;
TRACE((_T("ACTION_SET_FILE_SIZE(0x%lx, %d, 0x%x)\n"), GET_PCK_ARG1 (packet), offset, mode));
k = lookup_key (unit, GET_PCK_ARG1 (packet));
if (k == 0) {
PUT_PCK_RES1 (packet, DOS_TRUE);
PUT_PCK_RES2 (packet, ERROR_OBJECT_NOT_AROUND);
return;
}
if (k->aino->vfso) {
PUT_PCK_RES1 (packet, DOS_FALSE);
PUT_PCK_RES2 (packet, ERROR_DISK_WRITE_PROTECTED);
return;
}
/* Fail if file is >=2G, it is not safe operation. */
if (key_filesize(k) > MAXFILESIZE32_2G) {
PUT_PCK_RES1 (packet, DOS_TRUE);
PUT_PCK_RES2 (packet, ERROR_BAD_NUMBER); /* ? */
return;
}
gui_flicker_led (UNIT_LED(unit), unit->unit, 1);
k->notifyactive = 1;
/* If any open files have file pointers beyond this size, truncate only
* so far that these pointers do not become invalid. */
for (k1 = unit->keys; k1; k1 = k1->next) {
if (k != k1 && k->aino == k1->aino) {
if (k1->file_pos > offset)
offset = (off_t)k1->file_pos;
}
}
/* Write one then truncate: that should give the right size in all cases. */
fs_lseek (k->fd, offset, whence);
offset = fs_lseek (k->fd, 0, SEEK_CUR);
fs_write (k->fd, /* whatever */(uae_u8*)&k1, 1);
if (k->file_pos > offset)
k->file_pos = offset;
fs_lseek (k->fd, (off_t)k->file_pos, SEEK_SET);
/* Brian: no bug here; the file _must_ be one byte too large after writing
* The write is supposed to guarantee that the file can't be smaller than
* the requested size, the truncate guarantees that it can't be larger.
* If we were to write one byte earlier we'd clobber file data. */
if (my_truncate (k->aino->nname, offset) == -1) {
PUT_PCK_RES1 (packet, DOS_TRUE);
PUT_PCK_RES2 (packet, dos_errno ());
return;
}
PUT_PCK_RES1 (packet, offset);
PUT_PCK_RES2 (packet, 0);
}
static int relock_do(Unit *unit, a_inode *a1)
{
Key *k1, *knext;
int wehavekeys = 0;
for (k1 = unit->keys; k1; k1 = knext) {
knext = k1->next;
if (k1->aino == a1 && k1->fd) {
wehavekeys++;
fs_closefile (k1->fd);
write_log (_T("handle %p freed\n"), k1->fd);
}
}
return wehavekeys;
}
static void relock_re (Unit *unit, a_inode *a1, a_inode *a2, int failed)
{
Key *k1, *knext;
for (k1 = unit->keys; k1; k1 = knext) {
knext = k1->next;
if (k1->aino == a1 && k1->fd) {
int mode = (k1->dosmode & A_FIBF_READ) == 0 ? O_WRONLY : (k1->dosmode & A_FIBF_WRITE) == 0 ? O_RDONLY : O_RDWR;
mode |= O_BINARY;
if (failed) {
/* rename still failed, restore fd */
k1->fd = fs_openfile (unit, a1, mode);
write_log (_T("restoring old handle '%s' %d\n"), a1->nname, k1->dosmode);
} else {
/* transfer fd to new name */
if (a2) {
k1->aino = a2;
k1->fd = fs_openfile (unit, a2, mode);
write_log (_T("restoring new handle '%s' %d\n"), a2->nname, k1->dosmode);
} else {
write_log (_T("no new handle, deleting old lock(s).\n"));
}
}
if (k1->fd == NULL) {
write_log (_T("relocking failed '%s' -> '%s'\n"), a1->nname, a2->nname);
free_key (unit, k1);
} else {
key_seek(k1, k1->file_pos, SEEK_SET);
}
}
}
}
static void
action_delete_object (Unit *unit, dpacket packet)
{
uaecptr lock = GET_PCK_ARG1 (packet) << 2;
uaecptr name = GET_PCK_ARG2 (packet) << 2;
a_inode *a;
int err;
TRACE((_T("ACTION_DELETE_OBJECT(0x%lx,\"%s\")\n"), lock, bstr (unit, name)));
if (unit->ui.readonly || unit->ui.locked) {
PUT_PCK_RES1 (packet, DOS_FALSE);
PUT_PCK_RES2 (packet, ERROR_DISK_WRITE_PROTECTED);
return;
}
a = find_aino (unit, lock, bstr (unit, name), &err);
if (err != 0) {
PUT_PCK_RES1 (packet, DOS_FALSE);
PUT_PCK_RES2 (packet, err);
return;
}
if (a->amigaos_mode & A_FIBF_DELETE) {
PUT_PCK_RES1 (packet, DOS_FALSE);
PUT_PCK_RES2 (packet, ERROR_DELETE_PROTECTED);
return;
}
if (a->shlock > 0 || a->elock) {
PUT_PCK_RES1 (packet, DOS_FALSE);
PUT_PCK_RES2 (packet, ERROR_OBJECT_IN_USE);
return;
}
if (!a->vfso) {
if (a->dir) {
/* This should take care of removing the fsdb if no files remain. */
fsdb_dir_writeback (a);
if (my_rmdir (a->nname) == -1) {
PUT_PCK_RES1 (packet, DOS_FALSE);
PUT_PCK_RES2 (packet, dos_errno ());
return;
}
} else {
if (my_unlink (a->nname) == -1) {
PUT_PCK_RES1 (packet, DOS_FALSE);
PUT_PCK_RES2 (packet, dos_errno ());
return;
}
}
}
notify_check (unit, a);
updatedirtime (a, 1);
if (a->child != 0) {
write_log (_T("Serious error in action_delete_object.\n"));
a->deleted = 1;
} else {
delete_aino (unit, a);
}
PUT_PCK_RES1 (packet, DOS_TRUE);
gui_flicker_led (UNIT_LED(unit), unit->unit, 2);
}
static void
action_set_date (Unit *unit, dpacket packet)
{
uaecptr lock = GET_PCK_ARG2 (packet) << 2;
uaecptr name = GET_PCK_ARG3 (packet) << 2;
uaecptr date = GET_PCK_ARG4 (packet);
a_inode *a;
struct mytimeval tv;
int err = 0;
TRACE((_T("ACTION_SET_DATE(0x%lx,\"%s\")\n"), lock, bstr (unit, name)));
if (unit->ui.readonly || unit->ui.locked) {
PUT_PCK_RES1 (packet, DOS_FALSE);
PUT_PCK_RES2 (packet, ERROR_DISK_WRITE_PROTECTED);
return;
}
a = find_aino (unit, lock, bstr (unit, name), &err);
if (err != 0) {
PUT_PCK_RES1 (packet, DOS_FALSE);
PUT_PCK_RES2 (packet, err);
return;
}
if (a->softlink) {
handle_softlink (unit, packet, a);
return;
}
if (!a->vfso) {
amiga_to_timeval (&tv, get_long (date), get_long (date + 4), get_long (date + 8), 50);
//write_log (_T("%llu.%u (%d,%d,%d) %s\n"), tv.tv_sec, tv.tv_usec, get_long (date), get_long (date + 4), get_long (date + 8), a->nname);
if (!my_utime (a->nname, &tv))
err = dos_errno ();
}
if (err != 0) {
PUT_PCK_RES1 (packet, DOS_FALSE);
PUT_PCK_RES2 (packet, err);
return;
} else {
notify_check (unit, a);
PUT_PCK_RES1 (packet, DOS_TRUE);
}
gui_flicker_led (UNIT_LED(unit), unit->unit, 2);
}
static void
action_rename_object (Unit *unit, dpacket packet)
{
uaecptr lock1 = GET_PCK_ARG1 (packet) << 2;
uaecptr name1 = GET_PCK_ARG2 (packet) << 2;
uaecptr lock2 = GET_PCK_ARG3 (packet) << 2;
uaecptr name2 = GET_PCK_ARG4 (packet) << 2;
a_inode *a1, *a2;
int err1, err2;
Key *k1, *knext;
int wehavekeys = 0;
TRACE((_T("ACTION_RENAME_OBJECT(0x%lx,\"%s\","), lock1, bstr (unit, name1)));
TRACE((_T("0x%lx,\"%s\")\n"), lock2, bstr (unit, name2)));
if (unit->ui.readonly || unit->ui.locked) {
PUT_PCK_RES1 (packet, DOS_FALSE);
PUT_PCK_RES2 (packet, ERROR_DISK_WRITE_PROTECTED);
return;
}
a1 = find_aino (unit, lock1, bstr (unit, name1), &err1);
if (err1 != 0) {
PUT_PCK_RES1 (packet, DOS_FALSE);
PUT_PCK_RES2 (packet, err1);
return;
}
/* rename always fails if file is open for writing */
for (k1 = unit->keys; k1; k1 = knext) {
knext = k1->next;
if (k1->aino == a1 && k1->fd && k1->createmode == 2) {
PUT_PCK_RES1 (packet, DOS_FALSE);
PUT_PCK_RES2 (packet, ERROR_OBJECT_IN_USE);
return;
}
}
/* See whether the other name already exists in the filesystem. */
a2 = find_aino (unit, lock2, bstr (unit, name2), &err2);
if (a2 == a1) {
/* Renaming to the same name, but possibly different case. */
if (_tcscmp (a1->aname, bstr_cut (unit, name2)) == 0) {
/* Exact match -> do nothing. */
notify_check (unit, a1);
updatedirtime (a1, 1);
PUT_PCK_RES1 (packet, DOS_TRUE);
return;
}
a2 = a2->parent;
} else if (a2 == 0 || err2 != ERROR_OBJECT_NOT_AROUND) {
PUT_PCK_RES1 (packet, DOS_FALSE);
PUT_PCK_RES2 (packet, err2 == 0 ? ERROR_OBJECT_EXISTS : err2);
return;
}
a2 = create_child_aino (unit, a2, bstr_cut (unit, name2), a1->dir);
if (a2 == 0) {
PUT_PCK_RES1 (packet, DOS_FALSE);
PUT_PCK_RES2 (packet, ERROR_DISK_IS_FULL); /* best we can do */
return;
}
if (!a1->vfso) {
if (-1 == my_rename (a1->nname, a2->nname)) {
int ret = -1;
/* maybe we have open file handles that caused failure? */
write_log (_T("rename '%s' -> '%s' failed, trying relocking..\n"), a1->nname, a2->nname);
wehavekeys = relock_do (unit, a1);
/* try again... */
ret = my_rename (a1->nname, a2->nname);
/* restore locks */
relock_re (unit, a1, a2, ret == -1 ? 1 : 0);
if (ret == -1) {
delete_aino (unit, a2);
PUT_PCK_RES1 (packet, DOS_FALSE);
PUT_PCK_RES2 (packet, dos_errno ());
return;
}
}
}
notify_check (unit, a1);
notify_check (unit, a2);
a2->comment = a1->comment;
a1->comment = 0;
a2->amigaos_mode = a1->amigaos_mode;
a2->uniq = a1->uniq;
a2->elock = a1->elock;
a2->shlock = a1->shlock;
a2->has_dbentry = a1->has_dbentry;
a2->db_offset = a1->db_offset;
a2->dirty = 0;
a2->vfso = a1->vfso;
move_exkeys (unit, a1, a2);
move_aino_children (unit, a1, a2);
delete_aino (unit, a1);
a2->dirty = 1;
if (a2->parent)
fsdb_dir_writeback (a2->parent);
updatedirtime (a2, 1);
fsdb_set_file_attrs (a2);
if (a2->elock > 0 || a2->shlock > 0 || wehavekeys > 0)
de_recycle_aino (unit, a2);
PUT_PCK_RES1 (packet, DOS_TRUE);
gui_flicker_led (UNIT_LED(unit), unit->unit, 2);
}
static void
action_current_volume (Unit *unit, dpacket packet)
{
if (filesys_isvolume(unit))
PUT_PCK_RES1 (packet, unit->volume >> 2);
else
PUT_PCK_RES1 (packet, 0);
}
static void
action_rename_disk (Unit *unit, dpacket packet)
{
uaecptr name = GET_PCK_ARG1 (packet) << 2;
TRACE((_T("ACTION_RENAME_DISK(\"%s\")\n"), bstr (unit, name)));
if (unit->ui.readonly || unit->ui.locked) {
PUT_PCK_RES1 (packet, DOS_FALSE);
PUT_PCK_RES2 (packet, ERROR_DISK_WRITE_PROTECTED);
return;
}
/* get volume name */
xfree (unit->ui.volname);
unit->ui.volname = bstr1 (name);
set_volume_name (unit, 0);
PUT_PCK_RES1 (packet, DOS_TRUE);
}
static void
action_is_filesystem (Unit *unit, dpacket packet)
{
TRACE((_T("ACTION_IS_FILESYSTEM()\n")));
PUT_PCK_RES1 (packet, DOS_TRUE);
}
static void
action_flush (Unit *unit, dpacket packet)
{
TRACE((_T("ACTION_FLUSH()\n")));
PUT_PCK_RES1 (packet, DOS_TRUE);
flush_cache (unit, 0);
}
static void
action_more_cache (Unit *unit, dpacket packet)
{
TRACE((_T("ACTION_MORE_CACHE()\n")));
PUT_PCK_RES1 (packet, 50); /* bug but AmigaOS expects it */
if (GET_PCK_ARG1 (packet) != 0)
flush_cache (unit, 0);
}
static void
action_inhibit (Unit *unit, dpacket packet)
{
PUT_PCK_RES1 (packet, DOS_TRUE);
flush_cache (unit, 0);
unit->inhibited = GET_PCK_ARG1 (packet) != 0;
TRACE((_T("ACTION_INHIBIT(%d:%d)\n"), unit->unit, unit->inhibited));
}
static void
action_write_protect (Unit *unit, dpacket packet)
{
TRACE((_T("ACTION_WRITE_PROTECT()\n")));
PUT_PCK_RES1 (packet, DOS_TRUE);
if (GET_PCK_ARG1 (packet)) {
if (!unit->ui.locked) {
unit->ui.locked = true;
unit->lockkey = GET_PCK_ARG2 (packet);
}
} else {
if (unit->ui.locked) {
if (unit->lockkey == GET_PCK_ARG2 (packet) || unit->lockkey == 0) {
unit->ui.locked = false;
} else {
PUT_PCK_RES1 (packet, DOS_FALSE);
PUT_PCK_RES2 (packet, 0);
}
}
}
}
/* OS4 */
static void action_change_file_position64 (Unit *unit, dpacket packet)
{
Key *k = lookup_key (unit, GET_PCK64_ARG1 (packet));
uae_s64 pos = GET_PCK64_ARG2 (packet);
long mode = GET_PCK64_ARG3 (packet);
long whence = SEEK_CUR;
uae_s64 res, cur;
PUT_PCK64_RES0 (packet, DP64_INIT);
if (k == 0) {
PUT_PCK64_RES1 (packet, DOS_FALSE);
PUT_PCK64_RES2 (packet, ERROR_INVALID_LOCK);
return;
}
if (mode > 0)
whence = SEEK_END;
if (mode < 0)
whence = SEEK_SET;
TRACE((_T("ACTION_CHANGE_FILE_POSITION64(%s,%lld,%d)\n"), k->aino->nname, pos, mode));
gui_flicker_led (UNIT_LED(unit), unit->unit, 1);
cur = k->file_pos;
{
uae_s64 temppos;
uae_s64 filesize = key_filesize(k);
if (whence == SEEK_CUR)
temppos = cur + pos;
if (whence == SEEK_SET)
temppos = pos;
if (whence == SEEK_END)
temppos = filesize + pos;
if (filesize < temppos) {
res = -1;
PUT_PCK64_RES1 (packet, res);
PUT_PCK64_RES2 (packet, ERROR_SEEK_ERROR);
return;
}
}
res = key_seek(k, pos, whence);
if (-1 == res) {
PUT_PCK64_RES1 (packet, DOS_FALSE);
PUT_PCK64_RES2 (packet, ERROR_SEEK_ERROR);
} else {
PUT_PCK64_RES1 (packet, TRUE);
PUT_PCK64_RES2 (packet, 0);
k->file_pos = key_seek(k, 0, SEEK_CUR);
}
TRACE((_T("= oldpos %lld newpos %lld\n"), cur, k->file_pos));
}
static void action_get_file_position64 (Unit *unit, dpacket packet)
{
Key *k = lookup_key (unit, GET_PCK64_ARG1 (packet));
PUT_PCK64_RES0 (packet, DP64_INIT);
if (k == 0) {
PUT_PCK64_RES1 (packet, -1);
PUT_PCK64_RES2 (packet, ERROR_INVALID_LOCK);
return;
}
TRACE((_T("ACTION_GET_FILE_POSITION64(%s)=%lld\n"), k->aino->nname, k->file_pos));
PUT_PCK64_RES1 (packet, k->file_pos);
PUT_PCK64_RES2 (packet, 0);
}
static void action_change_file_size64 (Unit *unit, dpacket packet)
{
Key *k, *k1;
uae_s64 offset = GET_PCK64_ARG2 (packet);
long mode = (uae_s32)GET_PCK64_ARG3 (packet);
int whence = SEEK_CUR;
PUT_PCK64_RES0 (packet, DP64_INIT);
if (mode > 0)
whence = SEEK_END;
if (mode < 0)
whence = SEEK_SET;
TRACE((_T("ACTION_CHANGE_FILE_SIZE64(0x%lx, %lld, 0x%x)\n"), GET_PCK64_ARG1 (packet), offset, mode));
k = lookup_key (unit, GET_PCK64_ARG1 (packet));
if (k == 0) {
PUT_PCK64_RES1 (packet, DOS_FALSE);
PUT_PCK64_RES2 (packet, ERROR_OBJECT_NOT_AROUND);
return;
}
gui_flicker_led (UNIT_LED(unit), unit->unit, 1);
k->notifyactive = 1;
/* If any open files have file pointers beyond this size, truncate only
* so far that these pointers do not become invalid. */
for (k1 = unit->keys; k1; k1 = k1->next) {
if (k != k1 && k->aino == k1->aino) {
if (k1->file_pos > offset)
offset = k1->file_pos;
}
}
/* Write one then truncate: that should give the right size in all cases. */
fs_lseek (k->fd, offset, whence);
offset = key_seek(k, offset, whence);
fs_write (k->fd, /* whatever */(uae_u8*)&k1, 1);
if (k->file_pos > offset)
k->file_pos = offset;
key_seek(k, k->file_pos, SEEK_SET);
if (my_truncate (k->aino->nname, offset) == -1) {
PUT_PCK64_RES1 (packet, DOS_FALSE);
PUT_PCK64_RES2 (packet, dos_errno ());
return;
}
PUT_PCK64_RES1 (packet, DOS_TRUE);
PUT_PCK64_RES2 (packet, 0);
}
static void action_get_file_size64 (Unit *unit, dpacket packet)
{
Key *k = lookup_key (unit, GET_PCK64_ARG1 (packet));
uae_s64 filesize;
PUT_PCK64_RES0 (packet, DP64_INIT);
if (k == 0) {
PUT_PCK64_RES1 (packet, -1);
PUT_PCK64_RES2 (packet, ERROR_INVALID_LOCK);
return;
}
filesize = key_filesize(k);
TRACE((_T("ACTION_GET_FILE_SIZE64(%s)=%lld\n"), k->aino->nname, filesize));
if (filesize >= 0) {
PUT_PCK64_RES1 (packet, filesize);
PUT_PCK64_RES2 (packet, 0);
return;
}
PUT_PCK64_RES1 (packet, -1);
PUT_PCK64_RES2 (packet, ERROR_SEEK_ERROR);
}
/* MOS */
static void action_examine_object64(Unit *unit, dpacket packet)
{
uaecptr lock = GET_PCK_ARG1 (packet) << 2;
uaecptr info = GET_PCK_ARG2 (packet) << 2;
a_inode *aino = 0;
TRACE((_T("ACTION_EXAMINE_OBJECT(0x%lx,0x%lx)\n"), lock, info));
DUMPLOCK(unit, lock);
if (lock != 0)
aino = aino_from_lock (unit, lock);
if (aino == 0)
aino = &unit->rootnode;
get_fileinfo (unit, packet, info, aino, true);
}
static void action_set_file_size64(Unit *unit, dpacket packet)
{
Key *k, *k1;
uae_s64 offset = get_quadp(GET_PCK_ARG2 (packet));
long mode = (uae_s32)GET_PCK_ARG3 (packet);
int whence = SEEK_CUR;
if (mode > 0)
whence = SEEK_END;
if (mode < 0)
whence = SEEK_SET;
TRACE((_T("ACTION_SET_FILE_SIZE64(0x%lx, %lld, 0x%x)\n"), GET_PCK_ARG1 (packet), offset, mode));
k = lookup_key (unit, GET_PCK_ARG1 (packet));
if (k == 0) {
PUT_PCK_RES1 (packet, DOS_FALSE);
PUT_PCK_RES2 (packet, ERROR_OBJECT_NOT_AROUND);
return;
}
gui_flicker_led (UNIT_LED(unit), unit->unit, 1);
k->notifyactive = 1;
/* If any open files have file pointers beyond this size, truncate only
* so far that these pointers do not become invalid. */
for (k1 = unit->keys; k1; k1 = k1->next) {
if (k != k1 && k->aino == k1->aino) {
if (k1->file_pos > offset)
offset = k1->file_pos;
}
}
/* Write one then truncate: that should give the right size in all cases. */
fs_lseek (k->fd, offset, whence);
offset = key_seek(k, offset, whence);
fs_write (k->fd, /* whatever */(uae_u8*)&k1, 1);
if (k->file_pos > offset)
k->file_pos = offset;
key_seek(k, k->file_pos, SEEK_SET);
if (my_truncate (k->aino->nname, offset) == -1) {
PUT_PCK_RES1 (packet, DOS_FALSE);
PUT_PCK_RES2 (packet, dos_errno ());
return;
}
PUT_PCK_RES1 (packet, DOS_TRUE);
set_quadp(GET_PCK_ARG4(packet), offset);
}
static void action_seek64(Unit *unit, dpacket packet)
{
Key *k = lookup_key(unit, GET_PCK_ARG1(packet));
uae_s64 pos = get_quadp(GET_PCK64_ARG2(packet));
long mode = GET_PCK_ARG3(packet);
long whence = SEEK_CUR;
uae_s64 res, cur;
if (k == 0) {
PUT_PCK_RES1 (packet, DOS_FALSE);
PUT_PCK_RES2 (packet, ERROR_INVALID_LOCK);
return;
}
if (mode > 0)
whence = SEEK_END;
if (mode < 0)
whence = SEEK_SET;
TRACE((_T("ACTION_SEEK64(%s,%lld,%d)\n"), k->aino->nname, pos, mode));
gui_flicker_led (UNIT_LED(unit), unit->unit, 1);
cur = k->file_pos;
{
uae_s64 temppos;
uae_s64 filesize = key_filesize(k);
if (whence == SEEK_CUR)
temppos = cur + pos;
if (whence == SEEK_SET)
temppos = pos;
if (whence == SEEK_END)
temppos = filesize + pos;
if (filesize < temppos) {
res = -1;
PUT_PCK_RES1 (packet, res);
PUT_PCK_RES2 (packet, ERROR_SEEK_ERROR);
return;
}
}
res = key_seek(k, pos, whence);
if (-1 == res) {
PUT_PCK_RES1 (packet, DOS_FALSE);
PUT_PCK_RES2 (packet, ERROR_SEEK_ERROR);
} else {
PUT_PCK_RES1 (packet, TRUE);
set_quadp(GET_PCK_ARG3(packet), cur);
k->file_pos = key_seek(k, 0, SEEK_CUR);
}
TRACE((_T("= oldpos %lld newpos %lld\n"), cur, k->file_pos));
}
static int action_lock_record64(Unit *unit, dpacket packet, uae_u32 msg)
{
Key *k = lookup_key(unit, GET_PCK_ARG1(packet));
uae_u64 pos = get_quadp(GET_PCK_ARG2(packet));
uae_u64 len = get_quadp(GET_PCK_ARG3(packet));
uae_u32 mode = GET_PCK_ARG4(packet);
uae_u32 timeout = GET_PCK_ARG5(packet);
bool exclusive = mode == REC_EXCLUSIVE || mode == REC_EXCLUSIVE_IMMED;
write_log (_T("action_lock_record64('%s',%lld,%lld,%d,%d)\n"), k ? k->aino->nname : _T("null"), pos, len, mode, timeout);
if (!k || mode > REC_SHARED_IMMED) {
PUT_PCK_RES1 (packet, DOS_FALSE);
PUT_PCK_RES2 (packet, ERROR_OBJECT_WRONG_TYPE);
return 1;
}
if (mode == REC_EXCLUSIVE_IMMED || mode == REC_SHARED_IMMED)
timeout = 0;
if (record_hit (unit, k, pos, len, mode)) {
if (timeout && msg) {
// queue it and do not reply
struct lockrecord *lr = new_record (packet, pos, len, mode, timeout, msg);
if (unit->waitingrecords) {
lr->next = unit->waitingrecords;
unit->waitingrecords = lr;
} else {
unit->waitingrecords = lr;
}
write_log (_T("-> collision, timeout queued\n"));
return -1;
}
PUT_PCK_RES1 (packet, DOS_FALSE);
PUT_PCK_RES2 (packet, ERROR_LOCK_COLLISION);
write_log (_T("-> ERROR_LOCK_COLLISION\n"));
return 1;
}
struct lockrecord *lr = new_record (GET_PCK_ARG1(packet), pos, len, mode, timeout, 0);
if (k->record) {
lr->next = k->record;
k->record = lr;
} else {
k->record = lr;
}
PUT_PCK_RES1 (packet, DOS_TRUE);
write_log (_T("-> OK\n"));
return 1;
}
static void action_free_record64(Unit *unit, dpacket packet)
{
Key *k = lookup_key(unit, GET_PCK_ARG1(packet));
uae_u64 pos = get_quadp(GET_PCK_ARG2(packet));
uae_u64 len = get_quadp(GET_PCK_ARG3 (packet));
write_log (_T("action_free_record('%s',%lld,%lld)\n"), k ? k->aino->nname : _T("null"), pos, len);
if (!k) {
PUT_PCK_RES1 (packet, DOS_FALSE);
PUT_PCK_RES2 (packet, ERROR_OBJECT_WRONG_TYPE);
return;
}
struct lockrecord *prev = NULL;
for (struct lockrecord *lr = k->record; lr; lr = lr->next) {
if (lr->pos == pos && lr->len == len) {
if (prev)
prev->next = lr->next;
else
k->record = lr->next;
xfree (lr);
write_log (_T("->OK\n"));
record_check_waiting (unit);
PUT_PCK_RES1 (packet, DOS_TRUE);
return;
}
}
write_log (_T("-> ERROR_RECORD_NOT_LOCKED\n"));
PUT_PCK_RES1 (packet, DOS_FALSE);
PUT_PCK_RES2 (packet, ERROR_RECORD_NOT_LOCKED);
}
/* We don't want multiple interrupts to be active at the same time. I don't
* know whether AmigaOS takes care of that, but this does. */
static uae_sem_t singlethread_int_sem;
static uae_u32 REGPARAM2 exter_int_helper (TrapContext *context)
{
UnitInfo *uip = mountinfo.ui;
uaecptr port;
int n = m68k_dreg (regs, 0);
static int unit_no;
switch (n) {
case 0:
/* Determine whether a given EXTER interrupt is for us. */
if (uae_int_requested & 1) {
if (uae_sem_trywait (&singlethread_int_sem) != 0)
/* Pretend it isn't for us. We might get it again later. */
return 0;
/* Clear the interrupt flag _before_ we do any processing.
* That way, we can get too many interrupts, but never not
* enough. */
filesys_in_interrupt++;
uae_int_requested &= ~1;
unit_no = 0;
return 1;
}
return 0;
case 1:
/* Release a message_lock. This is called as soon as the message is
* received by the assembly code. We use the opportunity to check
* whether we have some locks that we can give back to the assembler
* code.
* Note that this is called from the main loop, unlike the other cases
* in this switch statement which are called from the interrupt handler.
*/
#ifdef UAE_FILESYS_THREADS
{
Unit *unit = find_unit (m68k_areg (regs, 5));
uaecptr msg = m68k_areg (regs, 4);
unit->cmds_complete = unit->cmds_acked;
while (comm_pipe_has_data (unit->ui.back_pipe)) {
uaecptr locks, lockend;
int cnt = 0;
locks = read_comm_pipe_int_blocking (unit->ui.back_pipe);
lockend = locks;
while (get_long (lockend) != 0) {
if (get_long (lockend) == lockend) {
write_log (_T("filesystem lock queue corrupted!\n"));
break;
}
lockend = get_long (lockend);
cnt++;
}
TRACE3((_T("message_lock: %d %x %x %x\n"), cnt, locks, lockend, m68k_areg (regs, 3)));
put_long (lockend, get_long (m68k_areg (regs, 3)));
put_long (m68k_areg (regs, 3), locks);
}
}
#else
write_log (_T("exter_int_helper should not be called with arg 1!\n"));
#endif
break;
case 2:
/* Find work that needs to be done:
* return d0 = 0: none
* d0 = 1: PutMsg(), port in a0, message in a1
* d0 = 2: Signal(), task in a1, signal set in d1
* d0 = 3: ReplyMsg(), message in a1
* d0 = 4: Cause(), interrupt in a1
* d0 = 5: Send FileNofication message, port in a0, notifystruct in a1
*/
#ifdef SUPPORT_THREADS
/* First, check signals/messages */
while (comm_pipe_has_data (&native2amiga_pending)) {
int cmd = read_comm_pipe_int_blocking (&native2amiga_pending);
switch (cmd) {
case 0: /* Signal() */
m68k_areg (regs, 1) = read_comm_pipe_u32_blocking (&native2amiga_pending);
m68k_dreg (regs, 1) = read_comm_pipe_u32_blocking (&native2amiga_pending);
return 2;
case 1: /* PutMsg() */
m68k_areg (regs, 0) = read_comm_pipe_u32_blocking (&native2amiga_pending);
m68k_areg (regs, 1) = read_comm_pipe_u32_blocking (&native2amiga_pending);
return 1;
case 2: /* ReplyMsg() */
m68k_areg (regs, 1) = read_comm_pipe_u32_blocking (&native2amiga_pending);
return 3;
case 3: /* Cause() */
m68k_areg (regs, 1) = read_comm_pipe_u32_blocking (&native2amiga_pending);
return 4;
case 4: /* NotifyHack() */
m68k_areg (regs, 0) = read_comm_pipe_u32_blocking (&native2amiga_pending);
m68k_areg (regs, 1) = read_comm_pipe_u32_blocking (&native2amiga_pending);
return 5;
default:
write_log (_T("exter_int_helper: unknown native action %X\n"), cmd);
break;
}
}
#endif
/* Find some unit that needs a message sent, and return its port,
* or zero if all are done.
* Take care not to dereference self for units that didn't have their
* startup packet sent. */
for (;;) {
if (unit_no >= MAX_FILESYSTEM_UNITS)
return 0;
if (uip[unit_no].open > 0 && uip[unit_no].self != 0
&& uip[unit_no].self->cmds_acked == uip[unit_no].self->cmds_complete
&& uip[unit_no].self->cmds_acked != uip[unit_no].self->cmds_sent)
break;
unit_no++;
}
uip[unit_no].self->cmds_acked = uip[unit_no].self->cmds_sent;
port = uip[unit_no].self->port;
if (port) {
m68k_areg (regs, 0) = port;
m68k_areg (regs, 1) = find_unit (port)->dummy_message;
unit_no++;
return 1;
}
break;
case 3:
uae_sem_wait (&singlethread_int_sem);
break;
case 4:
/* Exit the interrupt, and release the single-threading lock. */
filesys_in_interrupt--;
uae_sem_post (&singlethread_int_sem);
break;
default:
write_log (_T("Shouldn't happen in exter_int_helper.\n"));
break;
}
return 0;
}
static int handle_packet (Unit *unit, dpacket pck, uae_u32 msg)
{
uae_s32 type = GET_PCK_TYPE (pck);
PUT_PCK_RES2 (pck, 0);
TRACE((_T("unit=%x packet=%d\n"), unit, type));
if (unit->inhibited && filesys_isvolume (unit)
&& type != ACTION_INHIBIT && type != ACTION_MORE_CACHE
&& type != ACTION_DISK_INFO) {
PUT_PCK_RES1 (pck, DOS_FALSE);
PUT_PCK_RES2 (pck, ERROR_NOT_A_DOS_DISK);
return 1;
}
if (type != ACTION_INHIBIT && type != ACTION_CURRENT_VOLUME
&& type != ACTION_IS_FILESYSTEM && type != ACTION_MORE_CACHE
&& type != ACTION_WRITE_PROTECT && type != ACTION_DISK_INFO
&& !filesys_isvolume (unit)) {
PUT_PCK_RES1 (pck, DOS_FALSE);
PUT_PCK_RES2 (pck, unit->ui.unknown_media ? ERROR_NOT_A_DOS_DISK : ERROR_NO_DISK);
return 1;
}
switch (type) {
case ACTION_LOCATE_OBJECT: action_lock (unit, pck); break;
case ACTION_FREE_LOCK: action_free_lock (unit, pck); break;
case ACTION_COPY_DIR: action_dup_lock (unit, pck); break;
case ACTION_DISK_INFO: action_disk_info (unit, pck); break;
case ACTION_INFO: action_info (unit, pck); break;
case ACTION_EXAMINE_OBJECT: action_examine_object (unit, pck); break;
case ACTION_EXAMINE_NEXT: action_examine_next (unit, pck, false); break;
case ACTION_FIND_INPUT: action_find_input (unit, pck); break;
case ACTION_FIND_WRITE: action_find_write (unit, pck); break;
case ACTION_FIND_OUTPUT: action_find_output (unit, pck); break;
case ACTION_END: action_end (unit, pck); break;
case ACTION_READ: action_read (unit, pck); break;
case ACTION_WRITE: action_write (unit, pck); break;
case ACTION_SEEK: action_seek (unit, pck); break;
case ACTION_SET_PROTECT: action_set_protect (unit, pck); break;
case ACTION_SET_COMMENT: action_set_comment (unit, pck); break;
case ACTION_SAME_LOCK: action_same_lock (unit, pck); break;
case ACTION_PARENT: action_parent (unit, pck); break;
case ACTION_CREATE_DIR: action_create_dir (unit, pck); break;
case ACTION_DELETE_OBJECT: action_delete_object (unit, pck); break;
case ACTION_RENAME_OBJECT: action_rename_object (unit, pck); break;
case ACTION_SET_DATE: action_set_date (unit, pck); break;
case ACTION_CURRENT_VOLUME: action_current_volume (unit, pck); break;
case ACTION_RENAME_DISK: action_rename_disk (unit, pck); break;
case ACTION_IS_FILESYSTEM: action_is_filesystem (unit, pck); break;
case ACTION_FLUSH: action_flush (unit, pck); break;
case ACTION_MORE_CACHE: action_more_cache (unit, pck); break;
case ACTION_INHIBIT: action_inhibit (unit, pck); break;
case ACTION_WRITE_PROTECT: action_write_protect (unit, pck); break;
/* 2.0+ packet types */
case ACTION_SET_FILE_SIZE: action_set_file_size (unit, pck); break;
case ACTION_EXAMINE_FH: action_examine_fh (unit, pck, false); break;
case ACTION_FH_FROM_LOCK: action_fh_from_lock (unit, pck); break;
case ACTION_COPY_DIR_FH: action_lock_from_fh (unit, pck); break;
case ACTION_CHANGE_MODE: action_change_mode (unit, pck); break;
case ACTION_PARENT_FH: action_parent_fh (unit, pck); break;
case ACTION_ADD_NOTIFY: action_add_notify (unit, pck); break;
case ACTION_REMOVE_NOTIFY: action_remove_notify (unit, pck); break;
case ACTION_EXAMINE_ALL: return action_examine_all (unit, pck);
case ACTION_EXAMINE_ALL_END: return action_examine_all_end (unit, pck);
case ACTION_LOCK_RECORD: return action_lock_record (unit, pck, msg); break;
case ACTION_FREE_RECORD: action_free_record (unit, pck); break;
case ACTION_READ_LINK: action_read_link (unit, pck); break;
case ACTION_MAKE_LINK: action_make_link (unit, pck); break;
/* OS4 packet types */
case ACTION_CHANGE_FILE_POSITION64: action_change_file_position64 (unit, pck); break;
case ACTION_GET_FILE_POSITION64: action_get_file_position64 (unit, pck); break;
case ACTION_CHANGE_FILE_SIZE64: action_change_file_size64 (unit, pck); break;
case ACTION_GET_FILE_SIZE64: action_get_file_size64 (unit, pck); break;
/* MOS packet types */
case ACTION_SEEK64: action_seek64(unit, pck); break;
case ACTION_SET_FILE_SIZE64: action_set_file_size64(unit, pck); break;
case ACTION_EXAMINE_OBJECT64: action_examine_object64(unit, pck); break;
case ACTION_EXAMINE_NEXT64: action_examine_next(unit, pck, true); break;
case ACTION_EXAMINE_FH64: action_examine_fh(unit, pck, true); break;
case ACTION_LOCK_RECORD64: return action_lock_record64(unit, pck, msg); break;
case ACTION_FREE_RECORD64: action_free_record64(unit, pck); break;
/* unsupported packets */
case ACTION_FORMAT:
write_log (_T("FILESYS: UNSUPPORTED PACKET %x\n"), type);
return 0;
default:
write_log (_T("FILESYS: UNKNOWN PACKET %x\n"), type);
return 0;
}
return 1;
}
#ifdef UAE_FILESYS_THREADS
static int filesys_iteration(UnitInfo *ui)
{
dpacket pck;
uaecptr msg;
uae_u32 morelocks;
pck = read_comm_pipe_u32_blocking (ui->unit_pipe);
msg = read_comm_pipe_u32_blocking (ui->unit_pipe);
morelocks = (uae_u32)read_comm_pipe_int_blocking (ui->unit_pipe);
if (ui->reset_state == FS_GO_DOWN) {
if (pck != 0)
return 1;
/* Death message received. */
uae_sem_post (&ui->reset_sync_sem);
/* Die. */
return 0;
}
put_long (get_long (morelocks), get_long (ui->self->locklist));
put_long (ui->self->locklist, morelocks);
int ret = handle_packet (ui->self, pck, msg);
if (!ret) {
PUT_PCK_RES1 (pck, DOS_FALSE);
PUT_PCK_RES2 (pck, ERROR_ACTION_NOT_KNOWN);
}
if (ret >= 0) {
/* Mark the packet as processed for the list scan in the assembly code. */
put_long (msg + 4, 0xffffffff);
}
/* Acquire the message lock, so that we know we can safely send the message. */
ui->self->cmds_sent++;
/* The message is sent by our interrupt handler, so make sure an interrupt happens. */
do_uae_int_requested ();
/* Send back the locks. */
if (get_long (ui->self->locklist) != 0)
write_comm_pipe_int (ui->back_pipe, (int)(get_long (ui->self->locklist)), 0);
put_long (ui->self->locklist, 0);
return 1;
}
static void *filesys_thread (void *unit_v)
{
UnitInfo *ui = (UnitInfo *)unit_v;
uae_set_thread_priority (NULL, 1);
for (;;) {
if (!filesys_iteration (ui)) {
return 0;
}
}
return 0;
}
#endif
/* Talk about spaghetti code... */
static uae_u32 REGPARAM2 filesys_handler (TrapContext *context)
{
Unit *unit = find_unit (m68k_areg (regs, 5));
uaecptr packet_addr = m68k_dreg (regs, 3);
uaecptr message_addr = m68k_areg (regs, 4);
if (! valid_address (packet_addr, 36) || ! valid_address (message_addr, 14)) {
write_log (_T("FILESYS: Bad address %x/%x passed for packet.\n"), packet_addr, message_addr);
goto error2;
}
put_long (message_addr + 4, 0xffffffff);
if (!unit || !unit->volume) {
write_log (_T("FILESYS: was not initialized.\n"));
goto error;
}
#ifdef UAE_FILESYS_THREADS
{
uae_u32 morelocks;
if (!unit->ui.unit_pipe)
goto error;
/* Get two more locks and hand them over to the other thread. */
morelocks = get_long (m68k_areg (regs, 3));
put_long (m68k_areg (regs, 3), get_long (get_long (morelocks)));
put_long (get_long (morelocks), 0);
/* The packet wasn't processed yet. */
put_long (message_addr + 4, 0);
write_comm_pipe_u32 (unit->ui.unit_pipe, packet_addr, 0);
write_comm_pipe_u32 (unit->ui.unit_pipe, message_addr, 0);
write_comm_pipe_int (unit->ui.unit_pipe, (int)morelocks, 1);
/* Don't reply yet. */
return 1;
}
#endif
if (! handle_packet (unit, packet_addr, 0)) {
error:
PUT_PCK_RES1 (packet_addr, DOS_FALSE);
PUT_PCK_RES2 (packet_addr, ERROR_ACTION_NOT_KNOWN);
}
TRACE((_T("reply: %8lx, %ld\n"), GET_PCK_RES1 (packet_addr), GET_PCK_RES2 (packet_addr)));
error2:
return 0;
}
static void init_filesys_diagentry (void)
{
do_put_mem_long ((uae_u32 *)(filesys_bank.baseaddr + 0x2100), EXPANSION_explibname);
do_put_mem_long ((uae_u32 *)(filesys_bank.baseaddr + 0x2104), filesys_configdev);
do_put_mem_long ((uae_u32 *)(filesys_bank.baseaddr + 0x2108), EXPANSION_doslibname);
do_put_mem_word ((uae_u16 *)(filesys_bank.baseaddr + 0x210e), nr_units ());
do_put_mem_word ((uae_u16 *)(filesys_bank.baseaddr + 0x210c), 0);
native2amiga_startup ();
}
void filesys_start_threads (void)
{
int i;
filesys_in_interrupt = 0;
for (i = 0; i < MAX_FILESYSTEM_UNITS; i++) {
UnitInfo *ui = &mountinfo.ui[i];
if (ui->open <= 0)
continue;
filesys_start_thread (ui, i);
}
}
void filesys_cleanup (void)
{
filesys_free_handles ();
free_mountinfo ();
}
void filesys_free_handles (void)
{
Unit *u, *u1;
for (u = units; u; u = u1) {
Key *k1, *knext;
u1 = u->next;
for (k1 = u->keys; k1; k1 = knext) {
knext = k1->next;
if (k1->fd)
fs_closefile (k1->fd);
xfree (k1);
}
u->keys = NULL;
struct lockrecord *lrnext;
for (struct lockrecord *lr = u->waitingrecords; lr; lr = lrnext) {
lrnext = lr->next;
xfree (lr);
}
u->waitingrecords = NULL;
free_all_ainos (u, &u->rootnode);
u->rootnode.next = u->rootnode.prev = &u->rootnode;
u->aino_cache_size = 0;
xfree (u->newrootdir);
xfree (u->newvolume);
u->newrootdir = NULL;
u->newvolume = NULL;
}
}
static void filesys_reset2 (void)
{
Unit *u, *u1;
filesys_free_handles ();
for (u = units; u; u = u1) {
u1 = u->next;
xfree (u);
}
units = 0;
key_uniq = 0;
a_uniq = 0;
free_mountinfo ();
}
void filesys_reset (void)
{
if (isrestore ())
return;
load_injected_icons();
filesys_reset2 ();
initialize_mountinfo ();
}
static void filesys_prepare_reset2 (void)
{
UnitInfo *uip;
// Unit *u;
int i;
uip = mountinfo.ui;
#ifdef UAE_FILESYS_THREADS
for (i = 0; i < MAX_FILESYSTEM_UNITS; i++) {
if (uip[i].open > 0 && uip[i].unit_pipe != 0) {
uae_sem_init (&uip[i].reset_sync_sem, 0, 0);
uip[i].reset_state = FS_GO_DOWN;
/* send death message */
write_comm_pipe_int (uip[i].unit_pipe, 0, 0);
write_comm_pipe_int (uip[i].unit_pipe, 0, 0);
write_comm_pipe_int (uip[i].unit_pipe, 0, 1);
uae_sem_wait (&uip[i].reset_sync_sem);
uae_end_thread (&uip[i].tid);
}
}
#endif
filesys_free_handles();
#if 0
u = units;
while (u != 0) {
free_all_ainos (u, &u->rootnode);
u->rootnode.next = u->rootnode.prev = &u->rootnode;
u->aino_cache_size = 0;
u = u->next;
}
#endif
}
void filesys_prepare_reset (void)
{
if (isrestore ())
return;
filesys_prepare_reset2 ();
}
static uae_u32 REGPARAM2 filesys_diagentry (TrapContext *context)
{
uaecptr resaddr = m68k_areg (regs, 2) + 0x10;
uaecptr expansion = m68k_areg (regs, 5);
uaecptr start = resaddr;
uaecptr residents, tmp;
write_log (_T("filesystem: diagentry called: %x\n"), resaddr);
filesys_configdev = m68k_areg (regs, 3);
init_filesys_diagentry ();
if (ROM_hardfile_resid != 0) {
/* Build a struct Resident. This will set up and initialize
* the uae.device */
put_word (resaddr + 0x0, 0x4AFC);
put_long (resaddr + 0x2, resaddr);
put_long (resaddr + 0x6, resaddr + 0x1A); /* Continue scan here */
put_word (resaddr + 0xA, 0x8132); /* RTF_AUTOINIT|RTF_COLDSTART; Version 50 */
put_word (resaddr + 0xC, 0x0305); /* NT_DEVICE; pri 05 */
put_long (resaddr + 0xE, ROM_hardfile_resname);
put_long (resaddr + 0x12, ROM_hardfile_resid);
put_long (resaddr + 0x16, ROM_hardfile_init); /* calls filesys_init */
}
resaddr += 0x1A;
tmp = resaddr;
/* The good thing about this function is that it always gets called
* when we boot. So we could put all sorts of stuff that wants to be done
* here.
* We can simply add more Resident structures here. Although the Amiga OS
* only knows about the one at address DiagArea + 0x10, we scan for other
* Resident structures and call InitResident() for them at the end of the
* diag entry. */
resaddr = uaeres_startup (resaddr);
#ifdef BSDSOCKET
resaddr = bsdlib_startup (resaddr);
#endif
#ifdef WITH_UAENATIVE
resaddr = uaenative_startup (resaddr);
#endif
#ifdef SCSIEMU
resaddr = scsidev_startup (resaddr);
#endif
#ifdef SANA2
resaddr = netdev_startup (resaddr);
#endif
#ifdef UAESERIAL
resaddr = uaeserialdev_startup (resaddr);
#endif
#ifdef WITH_TABLETLIBRARY
resaddr = tabletlib_startup (resaddr);
#endif
/* scan for Residents and return pointer to array of them */
residents = resaddr;
while (tmp < residents && tmp > start) {
if (get_word (tmp) == 0x4AFC &&
get_long (tmp + 0x2) == tmp) {
put_word (resaddr, 0x227C); /* move.l #tmp,a1 */
put_long (resaddr + 2, tmp);
put_word (resaddr + 6, 0x7200); /* moveq #0,d1 */
put_long (resaddr + 8, 0x4EAEFF9A); /* jsr -$66(a6) ; InitResident */
resaddr += 12;
tmp = get_long (tmp + 0x6);
} else {
tmp += 2;
}
}
/* call setup_exter */
put_word (resaddr + 0, 0x2079);
put_long (resaddr + 2, rtarea_base + bootrom_header + 4 + 5 * 4); /* move.l RTAREA_BASE+setup_exter,a0 */
put_word (resaddr + 6, 0xd1fc);
put_long (resaddr + 8, rtarea_base + bootrom_header); /* add.l #RTAREA_BASE+bootrom_header,a0 */
put_word (resaddr + 12, 0x4e90); /* jsr (a0) */
put_word (resaddr + 14, 0x7001); /* moveq #1,d0 */
put_word (resaddr + 16, RTS);
m68k_areg (regs, 0) = residents;
if (currprefs.uae_hide_autoconfig) {
bool found = true;
while (found) {
uaecptr node = get_long (expansion + 0x3c);
found = false;
while (get_long (node)) {
if (get_word (node + 0x10 + 4) == 2011) {
uae_u8 prod = get_byte (node + 0x10 + 1);
if (prod != 2) {
// remove all 2011 boards except filesystem
found = true;
uaecptr succ = get_long (node);
uaecptr pred = get_long (node + 4);
put_long (pred, succ);
put_long (succ + 4, pred);
break;
}
// replace filesystem with A590/A2091 IDs..
put_byte (node + 0x10 + 1, 3);
put_word (node + 0x10 + 4, 514);
}
node = get_long (node);
}
}
}
return 1;
}
/* don't forget filesys.asm! */
#define PP_MAXSIZE 4 * 96
#define PP_FSSIZE 400
#define PP_FSPTR 404
#define PP_ADDTOFSRES 408
#define PP_FSRES 412
#define PP_FSRES_CREATED 416
#define PP_EXPLIB 420
#define PP_FSHDSTART 424
static uae_u32 REGPARAM2 filesys_dev_bootfilesys (TrapContext *context)
{
uaecptr devicenode = m68k_areg (regs, 3);
uaecptr parmpacket = m68k_areg (regs, 1);
uaecptr fsres = get_long (parmpacket + PP_FSRES);
uaecptr fsnode;
uae_u32 dostype, dostype2;
int no = m68k_dreg (regs, 6) & 0x7fffffff;
int unit_no = no & 65535;
UnitInfo *uip = &mountinfo.ui[unit_no];
int iscd = (m68k_dreg (regs, 6) & 0x80000000) != 0 || uip->unit_type == UNIT_CDFS;
int type;
if (iscd) {
if (!get_long (devicenode + 16))
put_long (devicenode + 16, cdfs_handlername);
return 0;
} else {
type = is_hardfile (unit_no);
}
if (type == FILESYS_VIRTUAL) {
if (!get_long (devicenode + 16))
put_long (devicenode + 16, fshandlername);
return 0;
}
if (get_long (parmpacket + PP_FSPTR) && !get_long (parmpacket + PP_ADDTOFSRES)) {
uaecptr fsptr = get_long (parmpacket + PP_FSPTR);
uip->filesysseg = fsptr;
// filesystem but was not added to fs.resource
uae_u32 pf = get_long (parmpacket + PP_FSHDSTART + 8); // fse_PatchFlags
for (int i = 0; i < 32; i++) {
if (pf & (1 << i))
put_long (devicenode + 4 + i * 4, get_long (parmpacket + PP_FSHDSTART + 8 + 4 + i * 4));
}
put_long (devicenode + 4 + 7 * 4, fsptr >> 2); // seglist
return 1;
}
dostype = get_long (parmpacket + 80);
fsnode = get_long (fsres + 18);
while (get_long (fsnode)) {
dostype2 = get_long (fsnode + 14);
if (dostype2 == dostype) {
uae_u32 pf = get_long (fsnode + 22); // fse_PatchFlags
for (int i = 0; i < 32; i++) {
if (pf & (1 << i))
put_long (devicenode + 4 + i * 4, get_long (fsnode + 22 + 4 + i * 4));
}
return 1;
}
fsnode = get_long (fsnode);
}
if (type == FILESYS_HARDFILE) {
uae_u32 pf = get_long (parmpacket + PP_FSHDSTART + 8); // fse_PatchFlags
for (int i = 0; i < 32; i++) {
if (pf & (1 << i))
put_long (devicenode + 4 + i * 4, get_long (parmpacket + PP_FSHDSTART + 8 + 4 + i * 4));
}
put_long (devicenode + 4 + 7 * 4, 0); // seglist
}
return 0;
}
extern void picasso96_alloc (TrapContext*);
static uae_u32 REGPARAM2 filesys_init_storeinfo (TrapContext *context)
{
int ret = -1;
switch (m68k_dreg (regs, 1))
{
case 1:
mountertask = m68k_areg (regs, 1);
#ifdef PICASSO96
picasso96_alloc (context);
#endif
break;
case 2:
ret = automountunit;
automountunit = -1;
break;
case 3:
return 0;
}
return ret;
}
static uae_u8 *cdfs_handler;
static int cdfs_handler_len;
/* Remember a pointer AmigaOS gave us so we can later use it to identify
* which unit a given startup message belongs to. */
static uae_u32 REGPARAM2 filesys_dev_remember (TrapContext *context)
{
int no = m68k_dreg (regs, 6) & 0x7fffffff;
int unit_no = no & 65535;
int sub_no = no >> 16;
UnitInfo *uip = &mountinfo.ui[unit_no];
int iscd = (m68k_dreg (regs, 6) & 0x80000000) != 0 || uip->unit_type == UNIT_CDFS;
int i;
uaecptr devicenode = m68k_areg (regs, 3);
uaecptr parmpacket = m68k_areg (regs, 1);
int fssize;
uae_u8 *fs;
uip->devicenode = devicenode;
fssize = uip->rdb_filesyssize;
fs = uip->rdb_filesysstore;
/* copy filesystem loaded from RDB */
if (get_long (parmpacket + PP_FSPTR)) {
for (i = 0; i < fssize; i++)
put_byte (get_long (parmpacket + PP_FSPTR) + i, fs[i]);
}
xfree (fs);
uip->rdb_filesysstore = 0;
uip->rdb_filesyssize = 0;
if (m68k_dreg (regs, 3) >= 0)
uip->startup = get_long (devicenode + 28);
return devicenode;
}
static int legalrdbblock (UnitInfo *uip, int block)
{
if (block <= 0)
return 0;
if (block >= uip->hf.virtsize / uip->hf.ci.blocksize)
return 0;
return 1;
}
static uae_u32 rl (uae_u8 *p)
{
return (p[0] << 24) | (p[1] << 16) | (p[2] << 8) | (p[3]);
}
int rdb_checksum (uae_char *id, uae_u8 *p, int block)
{
uae_u32 sum = 0;
int i, blocksize;
if (memcmp (id, p, 4))
return 0;
blocksize = rl (p + 4);
if (blocksize < 1 || blocksize * 4 > FILESYS_MAX_BLOCKSIZE)
return 0;
for (i = 0; i < blocksize; i++)
sum += rl (p + i * 4);
sum = -sum;
if (sum) {
TCHAR *s = au (id);
write_log (_T("RDB: block %d ('%s') checksum error\n"), block, s);
xfree (s);
return 0;
}
return 1;
}
static int device_isdup (uaecptr expbase, TCHAR *devname)
{
uaecptr bnode, dnode, name;
int len, i;
TCHAR dname[256];
bnode = get_long (expbase + 74); /* expansion.library bootnode list */
while (get_long (bnode)) {
dnode = get_long (bnode + 16); /* device node */
name = get_long (dnode + 40) << 2; /* device name BSTR */
len = get_byte (name);
for (i = 0; i < len; i++)
dname[i] = get_byte (name + 1 + i);
dname[len] = 0;
if (!_tcsicmp (devname, dname))
return 1;
bnode = get_long (bnode);
}
return 0;
}
static TCHAR *device_dupfix (uaecptr expbase, TCHAR *devname)
{
int modified;
TCHAR newname[256];
_tcscpy (newname, devname);
modified = 1;
while (modified) {
modified = 0;
if (device_isdup (expbase, newname)) {
if (_tcslen (newname) > 2 && newname[_tcslen (newname) - 2] == '_') {
newname[_tcslen (newname) - 1]++;
} else {
_tcscat (newname, _T("_0"));
}
modified = 1;
}
}
return my_strdup (newname);
}
static const TCHAR *dostypes (uae_u32 dostype)
{
static TCHAR dt[32];
int j;
j = 0;
for (int i = 0; i < 4; i++) {
uae_u8 c = dostype >> ((3 - i) * 8);
if (c >= ' ' && c <= 'z') {
dt[j++] = c;
} else {
dt[j++] = '\\';
_stprintf (&dt[j], _T("%d"), c);
j += _tcslen (&dt[j]);
}
}
dt[j] = 0;
return dt;
}
static void dump_partinfo (struct hardfiledata *hfd, uae_u8 *pp)
{
TCHAR *s;
uae_u32 dostype;
uae_u64 size;
int blocksize, surfaces, spb, spt, reserved;
int lowcyl, highcyl;
uae_u32 block, flags;
uae_u8 buf[512];
flags = rl (pp + 20);
pp[37 + pp[36]] = 0;
s = au ((char*)pp + 37);
pp += 128;
dostype = rl (pp + 64);
spb = rl (pp + 16);
blocksize = rl (pp + 4) * 4;
surfaces = rl (pp + 12);
spt = rl (pp + 20);
reserved = rl (pp + 24);
lowcyl = rl (pp + 36);
highcyl = rl (pp + 40);
size = ((uae_u64)blocksize) * surfaces * spt * (highcyl - lowcyl + 1);
write_log (_T("Partition '%s' Dostype=%08X (%s) Flags: %08X\n"), s[0] ? s : _T("_NULL_"), dostype, dostypes (dostype), flags);
write_log (_T("BlockSize: %d, Surfaces: %d, SectorsPerBlock %d\n"),
blocksize, surfaces, spb);
write_log (_T("SectorsPerTrack: %d, Reserved: %d, LowCyl %d, HighCyl %d, Size %dM\n"),
spt, reserved, lowcyl, highcyl, (uae_u32)(size >> 20));
write_log (_T("Buffers: %d, BufMemType: %08x, MaxTransfer: %08x, Mask: %08x, BootPri: %d\n"),
rl (pp + 44), rl (pp + 48), rl (pp + 52), rl (pp + 56), rl (pp + 60));
write_log (_T("Total blocks: %lld, Total disk blocks: %lld\n"), (uae_s64)surfaces * spt * (highcyl - lowcyl + 1), hfd->virtsize / blocksize);
if (hfd->drive_empty) {
write_log (_T("Empty drive\n"));
} else {
block = lowcyl * surfaces * spt;
if (hdf_read (hfd, buf, (uae_u64)blocksize * block, sizeof buf)) {
write_log (_T("First block %d dostype: %08X (%s)\n"), block, rl (buf), dostypes (rl (buf)));
} else {
write_log (_T("First block %d read failed!\n"), block);
}
xfree (s);
if ((uae_u64)highcyl * spt * surfaces * blocksize > hfd->virtsize) {
write_log (_T("RDB: WARNING: end of partition > size of disk! (%llu > %llu)\n"),
(uae_u64)highcyl * spt * surfaces * blocksize, hfd->virtsize);
}
}
}
static void dump_rdb (UnitInfo *uip, struct hardfiledata *hfd, uae_u8 *bufrdb, uae_u8 *buf, int readblocksize)
{
write_log (_T("RDB: HostID: %08x Flags: %08x\n"),
rl (bufrdb + 3 * 4), rl (bufrdb + 5 * 4));
write_log (_T("RDB: BL: %d BH: %d LC: %d HC: %d CB: %d HB: %d\n"),
rl (bufrdb + 128), rl (bufrdb + 132), rl (bufrdb + 136), rl (bufrdb + 140), rl (bufrdb + 144), rl (bufrdb + 152));
for (int i = 0; i < 100; i++) {
int partblock;
if (i == 0)
partblock = rl (bufrdb + 28);
else
partblock = rl (buf + 4 * 4);
if (partblock == 0xffffffff)
break;
write_log (_T("RDB: PART block %d:\n"), partblock);
if (!legalrdbblock (uip, partblock)) {
write_log (_T("RDB: corrupt PART pointer %d\n"), partblock);
break;
}
memset (buf, 0, readblocksize);
hdf_read (hfd, buf, partblock * hfd->ci.blocksize, readblocksize);
if (!rdb_checksum ("PART", buf, partblock)) {
write_log (_T("RDB: checksum error PART block %d\n"), partblock);
break;
}
dump_partinfo (hfd, buf);
}
for (int i = 0; i < 100; i++) {
int fileblock;
if (i == 0)
fileblock = rl (bufrdb + 32);
else
fileblock = rl (buf + 4 * 4);
if (fileblock == 0xffffffff)
break;
write_log (_T("RDB: LSEG block %d:\n"), fileblock);
if (!legalrdbblock (uip, fileblock)) {
write_log (_T("RDB: corrupt FSHD pointer %d\n"), fileblock);
break;
}
memset (buf, 0, readblocksize);
hdf_read (hfd, buf, fileblock * hfd->ci.blocksize, readblocksize);
if (!rdb_checksum ("FSHD", buf, fileblock)) {
write_log (_T("RDB: checksum error FSHD block %d\n"), fileblock);
break;
}
uae_u32 dostype = rl (buf + 32);
int version = (buf[36] << 8) | buf[37];
int revision = (buf[38] << 8) | buf[39];
write_log (_T("LSEG: %08x (%s) %d.%d\n"), dostype, dostypes (dostype), version, revision);
}
}
#define rdbmnt write_log (_T("Mounting uaehf.device %d (%d) (size=%llu):\n"), unit_no, partnum, hfd->virtsize);
static int rdb_mount (UnitInfo *uip, int unit_no, int partnum, uaecptr parmpacket)
{
int lastblock = 63, blocksize, readblocksize, badblock, driveinitblock;
uae_u8 bufrdb[FILESYS_MAX_BLOCKSIZE], *buf = 0;
uae_u8 *fsmem = 0;
int rdblock, partblock, fileblock, lsegblock, i;
uae_u32 flags;
struct hardfiledata *hfd = &uip->hf;
uae_u32 dostype;
uaecptr fsres, fsnode;
int err = 0;
int oldversion, oldrevision;
int newversion, newrevision;
TCHAR *s;
bool showdebug = partnum == 0;
write_log (_T("%s:\n"), uip->rootdir);
if (hfd->drive_empty) {
rdbmnt
write_log (_T("ignored, drive is empty\n"));
return -2;
}
if (hfd->ci.blocksize == 0) {
rdbmnt
write_log (_T("failed, blocksize == 0\n"));
return -1;
}
if (lastblock * hfd->ci.blocksize > hfd->virtsize) {
rdbmnt
write_log (_T("failed, too small (%d*%d > %llu)\n"), lastblock, hfd->ci.blocksize, hfd->virtsize);
return -2;
}
for (rdblock = 0; rdblock < lastblock; rdblock++) {
hdf_read_rdb (hfd, bufrdb, rdblock * hfd->ci.blocksize, hfd->ci.blocksize);
if (rdb_checksum ("RDSK", bufrdb, rdblock))
break;
if (rdb_checksum ("CDSK", bufrdb, rdblock))
break;
hdf_read_rdb (hfd, bufrdb, rdblock * hfd->ci.blocksize, hfd->ci.blocksize);
if (!memcmp ("RDSK", bufrdb, 4)) {
bufrdb[0xdc] = 0;
bufrdb[0xdd] = 0;
bufrdb[0xde] = 0;
bufrdb[0xdf] = 0;
if (rdb_checksum ("RDSK", bufrdb, rdblock)) {
write_log (_T("Windows 95/98/ME trashed RDB detected, fixing..\n"));
hdf_write (hfd, bufrdb, rdblock * hfd->ci.blocksize, hfd->ci.blocksize);
break;
}
}
}
if (rdblock == lastblock) {
rdbmnt
write_log (_T("failed, no RDB detected\n"));
return -2;
}
blocksize = rl (bufrdb + 16);
readblocksize = blocksize > hfd->ci.blocksize ? blocksize : hfd->ci.blocksize;
badblock = rl (bufrdb + 24);
if (badblock != -1) {
rdbmnt
write_log (_T("RDB: badblock list is not yet supported. Contact the author.\n"));
return -2;
}
driveinitblock = rl (bufrdb + 36);
if (driveinitblock != -1) {
rdbmnt
write_log (_T("RDB: driveinit is not yet supported. Contact the author.\n"));
return -2;
}
hfd->rdbcylinders = rl (bufrdb + 64);
hfd->rdbsectors = rl (bufrdb + 68);
hfd->rdbheads = rl (bufrdb + 72);
#if 0
{
int cyls, secs, heads;
getchsgeometry_hdf (hfd, hfd->virtsize, &cyls, &secs, &heads);
if (cyls * secs * heads > hfd->cylinders * hfd->sectors * hfd->heads) {
hfd->cylinders = cyls;
hfd->sectors = secs;
hfd->heads = heads;
}
}
#endif
fileblock = rl (bufrdb + 32);
buf = xmalloc (uae_u8, readblocksize);
if (showdebug) {
if ((uae_u64)hfd->rdbcylinders * hfd->rdbsectors * hfd->rdbheads * blocksize > hfd->virtsize)
write_log (_T("RDB: WARNING: RDSK header disk size > disk size! (%llu > %llu)\n"),
(uae_u64)hfd->rdbcylinders * hfd->rdbsectors * hfd->rdbheads * blocksize, hfd->virtsize);
write_log (_T("RDSK dump start\n"));
write_log (_T("RDSK at %d, C=%d S=%d H=%d\n"),
rdblock, hfd->rdbcylinders, hfd->rdbsectors, hfd->rdbheads);
dump_rdb (uip, hfd, bufrdb, buf, readblocksize);
write_log (_T("RDSK dump end\n"));
}
for (i = 0; i <= partnum; i++) {
if (i == 0)
partblock = rl (bufrdb + 28);
else
partblock = rl (buf + 4 * 4);
if (!legalrdbblock (uip, partblock)) {
err = -2;
goto error;
}
memset (buf, 0, readblocksize);
hdf_read (hfd, buf, partblock * hfd->ci.blocksize, readblocksize);
if (!rdb_checksum ("PART", buf, partblock)) {
err = -2;
goto error;
}
}
rdbmnt
flags = rl (buf + 20);
if ((flags & 2) || uip->bootpri <= -129) { /* do not mount */
err = -1;
write_log (_T("RDB: Automount disabled, not mounting\n"));
goto error;
}
if (!(flags & 1) || uip->bootpri <= -128) /* not bootable */
m68k_dreg (regs, 7) = m68k_dreg (regs, 7) & ~1;
buf[37 + buf[36]] = 0; /* zero terminate BSTR */
s = au ((char*)buf + 37);
uip->rdb_devname_amiga[partnum] = ds (device_dupfix (get_long (parmpacket + PP_EXPLIB), s));
xfree (s);
put_long (parmpacket, uip->rdb_devname_amiga[partnum]); /* name */
put_long (parmpacket + 4, ROM_hardfile_resname);
put_long (parmpacket + 8, uip->devno);
put_long (parmpacket + 12, 0); /* Device flags */
for (i = 0; i < PP_MAXSIZE; i++)
put_byte (parmpacket + 16 + i, buf[128 + i]);
dostype = get_long (parmpacket + 80);
uip->rdb_dostype = dostype;
if (dostype == 0) {
write_log (_T("RDB: mount failed, dostype=0\n"));
err = -1;
goto error;
}
if (dostype == 0xffffffff) {
write_log (_T("RDB: WARNING: dostype = 0xFFFFFFFF. FFS bug can report partition in \"no disk inserted\" state!!\n"));
}
err = 2;
/* load custom filesystems if needed */
if (fileblock == -1 || !legalrdbblock (uip, fileblock))
goto error;
fsres = get_long (parmpacket + PP_FSRES);
if (!fsres) {
write_log (_T("RDB: FileSystem.resource not found, this shouldn't happen!\n"));
goto error;
}
fsnode = get_long (fsres + 18);
while (get_long (fsnode)) {
if (get_long (fsnode + 14) == dostype)
break;
fsnode = get_long (fsnode);
}
oldversion = oldrevision = -1;
if (get_long (fsnode)) {
oldversion = get_word (fsnode + 18);
oldrevision = get_word (fsnode + 20);
} else {
fsnode = 0;
}
for (;;) {
if (fileblock == -1) {
if (!fsnode)
write_log (_T("RDB: FS %08X (%s) not in FileSystem.resource or in RDB\n"), dostype, dostypes (dostype));
goto error;
}
if (!legalrdbblock (uip, fileblock)) {
write_log (_T("RDB: corrupt FSHD pointer %d\n"), fileblock);
goto error;
}
memset (buf, 0, readblocksize);
hdf_read (hfd, buf, fileblock * hfd->ci.blocksize, readblocksize);
if (!rdb_checksum ("FSHD", buf, fileblock)) {
write_log (_T("RDB: checksum error in FSHD block %d\n"), fileblock);
goto error;
}
fileblock = rl (buf + 16);
uae_u32 rdbdostype = rl (buf + 32);
if (((dostype >> 8) == (rdbdostype >> 8) && (dostype != 0x444f5300 && (dostype & 0xffffff00) == 0x444f5300)) || (dostype == rdbdostype))
break;
}
newversion = (buf[36] << 8) | buf[37];
newrevision = (buf[38] << 8) | buf[39];
write_log (_T("RDB: RDB filesystem %08X (%s) version %d.%d\n"), dostype, dostypes (dostype), newversion, newrevision);
if (fsnode) {
write_log (_T("RDB: %08X (%s) in FileSystem.resource version %d.%d\n"), dostype, dostypes (dostype), oldversion, oldrevision);
}
if (newversion * 65536 + newrevision <= oldversion * 65536 + oldrevision && oldversion >= 0) {
write_log (_T("RDB: FS in FileSystem.resource is newer or same, ignoring RDB filesystem\n"));
goto error;
}
for (i = 0; i < 140; i++)
put_byte (parmpacket + PP_FSHDSTART + i, buf[32 + i]);
put_long (parmpacket + PP_FSHDSTART, dostype);
/* we found required FSHD block */
fsmem = xmalloc (uae_u8, 262144);
lsegblock = rl (buf + 72);
i = 0;
for (;;) {
int pb = lsegblock;
if (!legalrdbblock (uip, lsegblock))
goto error;
memset (buf, 0, readblocksize);
hdf_read (hfd, buf, lsegblock * hfd->ci.blocksize, readblocksize);
if (!rdb_checksum ("LSEG", buf, lsegblock))
goto error;
lsegblock = rl (buf + 16);
if (lsegblock == pb)
goto error;
if ((i + 1) * (blocksize - 20) >= 262144)
goto error;
memcpy (fsmem + i * (blocksize - 20), buf + 20, blocksize - 20);
i++;
if (lsegblock == -1)
break;
}
write_log (_T("RDB: Filesystem loaded, %d bytes\n"), i * (blocksize - 20));
put_long (parmpacket + PP_FSSIZE, i * (blocksize - 20)); /* RDB filesystem size hack */
put_long (parmpacket + PP_ADDTOFSRES, -1);
uip->rdb_filesysstore = fsmem;
uip->rdb_filesyssize = i * (blocksize - 20);
xfree (buf);
return 2;
error:
xfree (buf);
xfree (fsmem);
return err;
}
static void addfakefilesys (uaecptr parmpacket, uae_u32 dostype, int ver, int rev, struct uaedev_config_info *ci)
{
int i;
uae_u32 flags;
flags = 0x180;
for (i = 0; i < 140; i++)
put_byte (parmpacket + PP_FSHDSTART + i, 0);
if (dostype) {
put_long (parmpacket + 80, dostype);
put_long (parmpacket + PP_FSHDSTART, dostype);
}
if (ver >= 0 && rev >= 0)
put_long (parmpacket + PP_FSHDSTART + 4, (ver << 16) | rev);
put_long (parmpacket + PP_FSHDSTART + 12 + 4 * 4, ci->stacksize);
flags |= 0x10;
if (ci->priority != -129) {
put_long (parmpacket + PP_FSHDSTART + 12 + 5 * 4, ci->priority);
flags |= 0x20;
}
put_long (parmpacket + PP_FSHDSTART + 12 + 8 * 4, dostype == 0x444f5300 ? 0 : -1); // globvec
// if OFS = seglist -> NULL
if (dostype == 0x444f5300)
flags &= ~0x080;
put_long (parmpacket + PP_FSHDSTART + 8, flags); // patchflags
}
static uaecptr getfakefilesysseg (UnitInfo *uip)
{
if (uip->filesysdir && _tcslen (uip->filesysdir) > 0) {
for (int i = 0; &mountinfo.ui[i] != uip; i++) {
UnitInfo *uip2 = &mountinfo.ui[i];
if (!uip2->filesysdir)
continue;
if (_tcsicmp (uip2->filesysdir, uip->filesysdir) != 0)
continue;
if (uip2->filesysseg)
return uip2->filesysseg;
}
}
return 0;
}
static int dofakefilesys (UnitInfo *uip, uaecptr parmpacket, struct uaedev_config_info *ci)
{
int i, size;
TCHAR tmp[MAX_DPATH];
uae_u8 buf[512];
struct zfile *zf;
int ver = -1, rev = -1;
uae_u32 dostype;
bool autofs = false;
// we already have custom filesystem loaded for earlier hardfile?
if (!ci->forceload) {
uaecptr seg = getfakefilesysseg (uip);
if (seg) {
// yes, re-use it.
put_long (parmpacket + PP_FSSIZE, 0);
put_long (parmpacket + PP_FSPTR, seg);
put_long (parmpacket + PP_ADDTOFSRES, 0);
write_log (_T("RDB: faked RDB filesystem '%s' reused\n"), uip->filesysdir);
return FILESYS_HARDFILE;
}
}
if (!ci->dostype) {
memset (buf, 0, 4);
hdf_read (&uip->hf, buf, 0, 512);
dostype = (buf[0] << 24) | (buf[1] << 16) |(buf[2] << 8) | buf[3];
} else {
dostype = ci->dostype;
}
if (dostype == 0) {
addfakefilesys (parmpacket, dostype, ver, rev, ci);
return FILESYS_HARDFILE;
}
if (dostype == 0x444f5300 && (!uip->filesysdir || !uip->filesysdir[0])) {
write_log (_T("RDB: OFS, using ROM default FS.\n"));
return FILESYS_HARDFILE;
}
tmp[0] = 0;
if (uip->filesysdir && _tcslen (uip->filesysdir) > 0) {
_tcscpy (tmp, uip->filesysdir);
} else if ((dostype & 0xffffff00) == 0x444f5300) {
_tcscpy (tmp, currprefs.romfile);
i = _tcslen (tmp);
while (i > 0 && tmp[i - 1] != '/' && tmp[i - 1] != '\\')
i--;
_tcscpy (tmp + i, _T("FastFileSystem"));
autofs = true;
}
if (tmp[0] == 0) {
write_log (_T("RDB: no filesystem for dostype 0x%08X (%s)\n"), dostype, dostypes (dostype));
addfakefilesys (parmpacket, dostype, ver, rev, ci);
if ((dostype & 0xffffff00) == 0x444f5300)
return FILESYS_HARDFILE;
write_log (_T("RDB: mounted without filesys\n"));
return FILESYS_HARDFILE;
}
write_log (_T("RDB: fakefilesys, trying to load '%s', dostype 0x%08X (%s)\n"), tmp, dostype, dostypes (dostype));
zf = zfile_fopen (tmp, _T("rb"), ZFD_NORMAL);
if (!zf) {
addfakefilesys (parmpacket, dostype, ver, rev, ci);
write_log (_T("RDB: filesys not found, mounted without forced filesys\n"));
return FILESYS_HARDFILE;
}
uae_u32 fsres, fsnode;
int oldversion = -1;
int oldrevision = -1;
fsres = get_long (parmpacket + PP_FSRES);
fsnode = get_long (fsres + 18);
while (get_long (fsnode)) {
uae_u32 fsdostype = get_long (fsnode + 14);
if (fsdostype == dostype) {
oldversion = get_word (fsnode + 18);
oldrevision = get_word (fsnode + 20);
write_log (_T("RDB: %08X (%s) in FileSystem.resource version %d.%d\n"), dostype, dostypes (dostype), oldversion, oldrevision);
break;
}
fsnode = get_long (fsnode);
}
// if automatically found FastFileSystem, do not replace matching FileSystem.resource FS
if (autofs && oldversion >= 0) {
zfile_fclose (zf);
addfakefilesys (parmpacket, dostype, ver, rev, ci);
write_log (_T("RDB: not replacing FileSystem.resource\n"));
return FILESYS_HARDFILE;
}
zfile_fseek (zf, 0, SEEK_END);
size = zfile_ftell (zf);
if (size > 0) {
zfile_fseek (zf, 0, SEEK_SET);
uip->rdb_filesysstore = xmalloc (uae_u8, size);
zfile_fread (uip->rdb_filesysstore, size, 1, zf);
for (i = 0; i < size - 6; i++) {
uae_u8 *p = uip->rdb_filesysstore + i;
if (p[0] == 'V' && p[1] == 'E' && p[2] == 'R' && p[3] == ':' && p[4] == ' ') {
uae_u8 *p2;
p += 5;
p2 = p;
while (*p2 && p2 - uip->rdb_filesysstore < size)
p2++;
if (p2[0] == 0) {
while (*p && (ver < 0 || rev < 0)) {
if (*p == ' ') {
p++;
ver = atol ((char*)p);
if (ver < 0)
ver = 0;
while (*p) {
if (*p == ' ')
break;
if (*p == '.') {
p++;
rev = atol ((char*)p);
if (rev < 0)
rev = 0;
} else {
p++;
}
}
break;
} else {
p++;
}
}
}
break;
}
}
}
zfile_fclose (zf);
uip->rdb_filesyssize = size;
// DOS\0 is not in fs.resource and fs.resource already existed?
if (dostype == 0x444f5300 && oldversion < 0)
oldversion = 0;
put_long (parmpacket + PP_FSSIZE, uip->rdb_filesyssize);
put_long (parmpacket + PP_ADDTOFSRES, oldversion < 0 ? -1 : 0);
addfakefilesys (parmpacket, dostype, ver, rev, ci);
write_log (_T("RDB: faked RDB filesystem %08X (%s %d.%d) loaded. ADD2FS=%d\n"), dostype, dostypes (dostype), ver, rev, oldversion < 0 ? 1 : 0);
return FILESYS_HARDFILE;
}
static void get_new_device (int type, uaecptr parmpacket, TCHAR **devname, uaecptr *devname_amiga, int unit_no)
{
TCHAR buffer[80];
uaecptr expbase = get_long (parmpacket + PP_EXPLIB);
if (*devname == 0 || _tcslen (*devname) == 0) {
int un = unit_no;
for (;;) {
_stprintf (buffer, type == FILESYS_CD ? _T("CD%d") : _T("DH%d"), un++);
if (type == FILESYS_CD)
*devname = my_strdup (buffer);
if (!device_isdup (expbase, buffer))
break;
}
} else {
_tcscpy (buffer, *devname);
}
*devname_amiga = ds (device_dupfix (expbase, buffer));
if (type == FILESYS_CD)
write_log (_T("FS: mounted CD unit %s\n"), buffer);
else if (type == FILESYS_VIRTUAL)
write_log (_T("FS: mounted virtual unit %s (%s)\n"), buffer, mountinfo.ui[unit_no].rootdir);
else
write_log (_T("FS: mounted HDF unit %s (%04x-%08x, %s)\n"), buffer,
(uae_u32)(mountinfo.ui[unit_no].hf.virtsize >> 32),
(uae_u32)(mountinfo.ui[unit_no].hf.virtsize),
mountinfo.ui[unit_no].rootdir);
}
/* Fill in per-unit fields of a parampacket */
static uae_u32 REGPARAM2 filesys_dev_storeinfo (TrapContext *context)
{
UnitInfo *uip = mountinfo.ui;
int no = m68k_dreg (regs, 6) & 0x7fffffff;
int unit_no = no & 65535;
int sub_no = no >> 16;
int iscd = (m68k_dreg (regs, 6) & 0x80000000) != 0 || uip[unit_no].unit_type == UNIT_CDFS;
int type;
uaecptr parmpacket = m68k_areg (regs, 0);
struct uaedev_config_info *ci = &uip[unit_no].hf.ci;
put_long (parmpacket + PP_ADDTOFSRES, 0);
put_long (parmpacket + PP_FSSIZE, 0);
if (iscd) {
TCHAR *cdname = NULL;
uaecptr cdname_amiga;
int cd_unit_no = unit_no - cd_unit_offset;
if (sub_no)
return -2;
type = FILESYS_CD;
get_new_device (type, parmpacket, &uip[unit_no].devname, &uip[unit_no].devname_amiga, cd_unit_no);
cdname_amiga = uip[unit_no].devname_amiga;
uip[unit_no].devno = unit_no;
type = FILESYS_VIRTUAL;
gui_flicker_led (LED_CD, cd_unit_no, 0);
write_log (_T("Mounting uaescsi.device %d: (%d)\n"), cd_unit_no, unit_no);
put_long (parmpacket + 0, cdname_amiga);
put_long (parmpacket + 4, cdfs_devname);
put_long (parmpacket + 8, cd_unit_no);
put_long (parmpacket + 12, 0); /* Device flags */
put_long (parmpacket + 16, 19); /* Env. size */
put_long (parmpacket + 20, 2048 >> 2); /* longwords per block */
put_long (parmpacket + 24, 0); /* unused */
put_long (parmpacket + 28, 1); /* heads */
put_long (parmpacket + 32, 1); /* sectors per block */
put_long (parmpacket + 36, 1); /* sectors per track */
put_long (parmpacket + 40, 0); /* reserved blocks */
put_long (parmpacket + 44, 0); /* unused */
put_long (parmpacket + 48, 0); /* interleave */
put_long (parmpacket + 52, 0); /* lowCyl */
put_long (parmpacket + 56, 0); /* hiCyl */
put_long (parmpacket + 60, 50); /* Number of buffers */
put_long (parmpacket + 64, 1); /* Buffer mem type */
put_long (parmpacket + 68, 0x7FFFFFFE); /* largest transfer */
put_long (parmpacket + 72, 0xFFFFFFFE); /* dma mask */
put_long (parmpacket + 76, scsi_get_cd_drive_media_mask () & (1 << cd_unit_no) ? -127 : -128); /* bootPri */
put_long (parmpacket + 80, CDFS_DOSTYPE | (((cd_unit_no / 10) + '0') << 8) | ((cd_unit_no % 10) + '0'));
put_long (parmpacket + 84, 0); /* baud */
put_long (parmpacket + 88, 0); /* control */
put_long (parmpacket + 92, 0); /* bootblocks */
return type;
} else {
gui_flicker_led (LED_HD, unit_no, 0);
type = is_hardfile (unit_no);
if (type == FILESYS_HARDFILE_RDB || type == FILESYS_HARDDRIVE) {
/* RDB hardfile */
uip[unit_no].devno = unit_no;
return rdb_mount (&uip[unit_no], unit_no, sub_no, parmpacket);
}
if (sub_no)
return -2;
write_log (_T("Mounting uaehf.device %d (%d):\n"), unit_no, sub_no);
get_new_device (type, parmpacket, &uip[unit_no].devname, &uip[unit_no].devname_amiga, unit_no);
uip[unit_no].devno = unit_no;
put_long (parmpacket, uip[unit_no].devname_amiga);
put_long (parmpacket + 8, uip[unit_no].devno);
put_long (parmpacket + 12, 0); /* Device flags */
put_long (parmpacket + 16, 16); /* Env. size */
put_long (parmpacket + 24, 0); /* unused */
put_long (parmpacket + 44, 0); /* unused */
put_long (parmpacket + 48, 0); /* interleave */
put_long (parmpacket + 60, 50); /* Number of buffers */
put_long (parmpacket + 64, 1); /* Buffer mem type */
put_long (parmpacket + 68, 0x7FFFFFFE); /* largest transfer */
put_long (parmpacket + 72, 0xFFFFFFFE); /* dma mask */
put_long (parmpacket + 76, uip[unit_no].bootpri); /* bootPri */
put_long (parmpacket + 80, DISK_TYPE_DOS); /* DOS\0 */
if (type == FILESYS_VIRTUAL) {
put_long (parmpacket + 4, fsdevname);
put_long (parmpacket + 20, 512 >> 2); /* longwords per block */
put_long (parmpacket + 28, 15); /* heads */
put_long (parmpacket + 32, 1); /* sectors per block */
put_long (parmpacket + 36, 127); /* sectors per track */
put_long (parmpacket + 40, 2); /* reserved blocks */
put_long (parmpacket + 52, 0); /* lowCyl */
put_long (parmpacket + 56, 1); /* hiCyl */
} else {
uae_u8 buf[512];
put_long (parmpacket + 4, ROM_hardfile_resname);
put_long (parmpacket + 20, ci->blocksize >> 2); /* longwords per block */
put_long (parmpacket + 28, ci->surfaces); /* heads */
put_long (parmpacket + 32, ci->sectorsperblock); /* sectors per block */
put_long (parmpacket + 36, ci->sectors); /* sectors per track */
put_long (parmpacket + 40, ci->reserved); /* reserved blocks */
put_long (parmpacket + 52, ci->lowcyl); /* lowCyl */
put_long (parmpacket + 56, ci->highcyl <= 0 ? ci->cyls - 1 : ci->highcyl - 1); /* hiCyl */
put_long (parmpacket + 48, ci->interleave); /* interleave */
put_long (parmpacket + 60, ci->buffers); /* Number of buffers */
put_long (parmpacket + 64, ci->bufmemtype); /* Buffer mem type */
put_long (parmpacket + 68, ci->maxtransfer); /* largest transfer */
put_long (parmpacket + 72, ci->mask); /* dma mask */
memset(buf, 0, sizeof buf);
if (ci->dostype) { // forced dostype?
put_long (parmpacket + 80, ci->dostype); /* dostype */
} else if (hdf_read (&uip[unit_no].hf, buf, 0, sizeof buf)) {
uae_u32 dt = rl (buf);
if (dt != 0x00000000 && dt != 0xffffffff)
put_long (parmpacket + 80, dt);
}
memset(buf, 0, sizeof buf);
char *s = ua_fs(uip[unit_no].devname, -1);
buf[36] = strlen(s);
for (int i = 0; i < buf[36]; i++)
buf[37 + i] = s[i];
xfree(s);
for (int i = 0; i < 80; i++)
buf[i + 128] = get_byte (parmpacket + 16 + i);
dump_partinfo (&uip[unit_no].hf, buf);
}
if (type == FILESYS_HARDFILE)
type = dofakefilesys (&uip[unit_no], parmpacket, ci);
if (uip[unit_no].bootpri < -127 || (type == FILESYS_HARDFILE && ci->rootdir[0] == 0))
m68k_dreg (regs, 7) = m68k_dreg (regs, 7) & ~1; /* do not boot */
if (uip[unit_no].bootpri < -128)
return -1; /* do not mount */
return type;
}
}
static uae_u32 REGPARAM2 mousehack_done (TrapContext *context)
{
int mode = m68k_dreg (regs, 1);
if (mode < 10) {
uaecptr diminfo = m68k_areg (regs, 2);
uaecptr dispinfo = m68k_areg (regs, 3);
uaecptr vp = m68k_areg (regs, 4);
return input_mousehack_status (mode, diminfo, dispinfo, vp, m68k_dreg (regs, 2));
} else if (mode == 10) {
amiga_clipboard_die ();
} else if (mode == 11) {
amiga_clipboard_got_data (m68k_areg (regs, 2), m68k_dreg (regs, 2), m68k_dreg (regs, 0) + 8);
} else if (mode == 12) {
return amiga_clipboard_want_data ();
} else if (mode == 13) {
return amiga_clipboard_proc_start ();
} else if (mode == 14) {
amiga_clipboard_task_start (m68k_dreg (regs, 0));
} else if (mode == 15) {
amiga_clipboard_init ();
} else if (mode == 16) {
uaecptr a2 = m68k_areg (regs, 2);
input_mousehack_mouseoffset (a2);
} else if (mode == 17) {
uae_u32 v = 0;
if (currprefs.clipboard_sharing)
v |= 1;
if (consolehook_activate ())
v |= 2;
return v;
} else if (mode == 18) {
return rtarea_base + RTAREA_HEARTBEAT;
} else if (mode == 101) {
consolehook_ret (m68k_areg (regs, 1), m68k_areg (regs, 2));
} else if (mode == 102) {
uaecptr ret = consolehook_beginio (m68k_areg (regs, 1));
put_long (m68k_areg (regs, 7) + 4 * 4, ret);
} else {
write_log (_T("Unknown mousehack hook %d\n"), mode);
}
return 1;
}
extern void cia_heartbeat (void);
void filesys_vsync (void)
{
Unit *u;
if (uae_boot_rom_type <= 0)
return;
if (heartbeat == get_long (rtarea_base + RTAREA_HEARTBEAT)) {
if (heartbeat_count > 0)
heartbeat_count--;
return;
}
heartbeat = get_long (rtarea_base + RTAREA_HEARTBEAT);
cia_heartbeat ();
for (u = units; u; u = u->next) {
if (u->reinsertdelay > 0) {
u->reinsertdelay--;
if (u->reinsertdelay == 0) {
filesys_insert (u->unit, u->newvolume, u->newrootdir, u->newreadonly, u->newflags);
xfree (u->newvolume);
u->newvolume = NULL;
xfree (u->newrootdir);
u->newrootdir = NULL;
}
}
record_timeout (u);
}
for (int i = 0; i < currprefs.mountitems; i++) {
struct hardfiledata *hfd = get_hardfile_data (currprefs.mountconfig[i].configoffset);
if (!hfd)
continue;
if (hfd->reinsertdelay > 0) {
hfd->reinsertdelay--;
if (hfd->reinsertdelay == 0) {
hfd->reinsertdelay = -1;
hardfile_media_change (hfd, &hfd->delayedci, true, true);
}
}
}
if (heartbeat_count <= 0)
return;
if (heartbeat_task & 1) {
setsystime_vblank ();
heartbeat_task &= ~1;
}
}
void filesys_install (void)
{
uaecptr loop;
TRACEI ((_T("Installing filesystem\n")));
uae_sem_init (&singlethread_int_sem, 0, 1);
uae_sem_init (&test_sem, 0, 1);
ROM_filesys_resname = ds_ansi ("UAEunixfs.resource");
ROM_filesys_resid = ds_ansi ("UAE unixfs 0.4");
fsdevname = ds_ansi ("uae.device"); /* does not really exist */
fshandlername = ds_bstr_ansi ("uaefs");
cdfs_devname = ds_ansi ("uaescsi.device");
cdfs_handlername = ds_bstr_ansi ("uaecdfs");
ROM_filesys_diagentry = here ();
calltrap (deftrap2 (filesys_diagentry, 0, _T("filesys_diagentry")));
dw(0x4ED0); /* JMP (a0) - jump to code that inits Residents */
loop = here ();
org (rtarea_base + RTAREA_HEARTBEAT);
dl (0);
heartbeat = 0;
heartbeat_task = 0;
org (rtarea_base + 0xFF18);
calltrap (deftrap2 (filesys_dev_bootfilesys, 0, _T("filesys_dev_bootfilesys")));
dw (RTS);
/* Special trap for the assembly make_dev routine */
org (rtarea_base + 0xFF20);
calltrap (deftrap2 (filesys_dev_remember, 0, _T("filesys_dev_remember")));
dw (RTS);
org (rtarea_base + 0xFF28);
calltrap (deftrap2 (filesys_dev_storeinfo, 0, _T("filesys_dev_storeinfo")));
dw (RTS);
org (rtarea_base + 0xFF30);
calltrap (deftrap2 (filesys_handler, 0, _T("filesys_handler")));
dw (RTS);
org (rtarea_base + 0xFF38);
calltrap (deftrap2 (mousehack_done, 0, _T("mousehack_done")));
dw (RTS);
org (rtarea_base + 0xFF40);
calltrap (deftrap2 (startup_handler, 0, _T("startup_handler")));
dw (RTS);
org (rtarea_base + 0xFF48);
calltrap (deftrap2 (filesys_init_storeinfo, TRAPFLAG_EXTRA_STACK, _T("filesys_init_storeinfo")));
dw (RTS);
org (rtarea_base + 0xFF50);
calltrap (deftrap2 (exter_int_helper, 0, _T("exter_int_helper")));
dw (RTS);
org (rtarea_base + 0xFF58);
calltrap (deftrap2 (fsmisc_helper, 0, _T("fsmisc_helper")));
dw (RTS);
org (loop);
}
void filesys_install_code (void)
{
uae_u32 a, b, items;
bootrom_header = 3 * 4;
align(4);
a = here ();
#include "filesys_bootrom.cpp"
items = dlg (a + 8) & 0xffff;
/* The last offset comes from the code itself, look for it near the top. */
EXPANSION_bootcode = a + bootrom_header + items * 4 - 4;
b = a + bootrom_header + 3 * 4 - 4;
filesys_initcode = a + dlg (b) + bootrom_header - 4;
}
#ifdef _WIN32
#include "od-win32/win32_filesys.cpp"
#endif
static uae_u8 *restore_filesys_hardfile (UnitInfo *ui, uae_u8 *src)
{
struct hardfiledata *hfd = &ui->hf;
TCHAR *s;
hfd->virtsize = restore_u64 ();
hfd->offset = restore_u64 ();
hfd->ci.highcyl = restore_u32 ();
hfd->ci.sectors = restore_u32 ();
hfd->ci.surfaces = restore_u32 ();
hfd->ci.reserved = restore_u32 ();
hfd->ci.blocksize = restore_u32 ();
hfd->ci.readonly = restore_u32 () != 0;
hfd->flags = restore_u32 ();
hfd->rdbcylinders = restore_u32 ();
hfd->rdbsectors = restore_u32 ();
hfd->rdbheads = restore_u32 ();
s = restore_string ();
_tcscpy (hfd->vendor_id, s);
xfree (s);
s = restore_string ();
_tcscpy (hfd->product_id, s);
xfree (s);
s = restore_string ();
_tcscpy (hfd->product_rev, s);
xfree (s);
s = restore_string ();
_tcscpy (hfd->ci.devname, s);
xfree (s);
return src;
}
static uae_u8 *save_filesys_hardfile (UnitInfo *ui, uae_u8 *dst)
{
struct hardfiledata *hfd = &ui->hf;
save_u64 (hfd->virtsize);
save_u64 (hfd->offset);
save_u32 (hfd->ci.highcyl);
save_u32 (hfd->ci.sectors);
save_u32 (hfd->ci.surfaces);
save_u32 (hfd->ci.reserved);
save_u32 (hfd->ci.blocksize);
save_u32 (hfd->ci.readonly);
save_u32 (hfd->flags);
save_u32 (hfd->rdbcylinders);
save_u32 (hfd->rdbsectors);
save_u32 (hfd->rdbheads);
save_string (hfd->vendor_id);
save_string (hfd->product_id);
save_string (hfd->product_rev);
save_string (hfd->ci.devname);
return dst;
}
static a_inode *restore_filesys_get_base (Unit *u, TCHAR *npath)
{
TCHAR *path, *p, *p2;
a_inode *a;
int cnt, err, i;
/* no '/' = parent is root */
if (!_tcschr (npath, '/'))
return &u->rootnode;
/* iterate from root to last to previous path part,
* create ainos if not already created.
*/
path = xcalloc(TCHAR, _tcslen (npath) + 2);
cnt = 1;
for (;;) {
_tcscpy (path, npath);
p = path;
for (i = 0; i < cnt ;i++) {
if (i > 0)
p++;
while (*p != '/' && *p != 0)
p++;
}
if (*p) {
*p = 0;
err = 0;
get_aino (u, &u->rootnode, path, &err);
if (err) {
write_log (_T("*** FS: missing path '%s'!\n"), path);
return NULL;
}
cnt++;
} else {
break;
}
}
/* find base (parent) of last path part */
_tcscpy (path, npath);
p = path;
a = u->rootnode.child;
for (;;) {
if (*p == 0) {
write_log (_T("*** FS: base aino NOT found '%s' ('%s')\n"), a->nname, npath);
xfree (path);
return NULL;
}
p2 = p;
while(*p2 != '/' && *p2 != '\\' && *p2 != 0)
p2++;
*p2 = 0;
while (a) {
if (!same_aname(p, a->aname)) {
a = a->sibling;
continue;
}
p = p2 + 1;
if (*p == 0) {
write_log (_T("FS: base aino found '%s' ('%s')\n"), a->nname, npath);
xfree (path);
return a;
}
a = a->child;
break;
}
if (!a) {
write_log (_T("*** FS: path part '%s' not found ('%s')\n"), p, npath);
xfree (path);
return NULL;
}
}
}
static TCHAR *makenativepath (UnitInfo *ui, TCHAR *apath)
{
int i;
TCHAR *pn;
/* create native path. FIXME: handle 'illegal' characters */
pn = xcalloc (TCHAR, _tcslen (apath) + 1 + _tcslen (ui->rootdir) + 1);
_stprintf (pn, _T("%s/%s"), ui->rootdir, apath);
if (FSDB_DIR_SEPARATOR != '/') {
for (i = 0; i < _tcslen (pn); i++) {
if (pn[i] == '/')
pn[i] = FSDB_DIR_SEPARATOR;
}
}
return pn;
}
static uae_u8 *restore_aino (UnitInfo *ui, Unit *u, uae_u8 *src)
{
TCHAR *p, *p2, *pn;
uae_u32 flags;
int missing;
a_inode *base, *a;
missing = 0;
a = xcalloc (a_inode, 1);
a->uniq = restore_u64 ();
a->locked_children = restore_u32 ();
a->exnext_count = restore_u32 ();
a->shlock = restore_u32 ();
flags = restore_u32 ();
if (flags & 1)
a->elock = 1;
if (flags & 4)
a->uniq_external = restore_u64 ();
/* full Amiga-side path without drive, eg. "C/SetPatch" */
p = restore_string ();
/* root (p = volume label) */
if (a->uniq == 0) {
a->nname = my_strdup (ui->rootdir);
a->aname = p;
a->dir = 1;
if (ui->volflags < 0) {
write_log (_T("FS: Volume '%s' ('%s') missing!\n"), a->aname, a->nname);
} else {
a->volflags = ui->volflags;
recycle_aino (u, a);
write_log (_T("FS: Lock (root) '%s' ('%s')\n"), a->aname, a->nname);
}
return src;
}
p2 = _tcsrchr(p, '/');
if (p2)
p2++;
else
p2 = p;
pn = makenativepath (ui, p);
a->nname = pn;
a->aname = my_strdup (p2);
/* create path to parent dir */
if (p2 != p)
p2[0] = 0;
/* find parent of a->aname (Already restored previously. I hope..) */
base = restore_filesys_get_base (u, p);
xfree(p);
if (flags & 2) {
a->dir = 1;
if (!my_existsdir(a->nname))
write_log (_T("*** FS: Directory '%s' missing!\n"), a->nname);
else
fsdb_clean_dir (a);
} else {
if (!my_existsfile(a->nname))
write_log (_T("*** FS: File '%s' missing!\n"), a->nname);
}
if (base) {
fill_file_attrs (u, base, a);
init_child_aino_tree (u, base, a);
} else {
write_log (_T("*** FS: parent directory missing '%s' ('%s')\n"), a->aname, a->nname);
missing = 1;
}
if (missing) {
write_log (_T("*** FS: Lock restore failed '%s' ('%s')\n"), a->aname, a->nname);
xfree (a->nname);
xfree (a->aname);
xfree (a);
} else {
write_log (_T("FS: Lock '%s' ('%s')\n"), a->aname, a->nname);
recycle_aino (u, a);
}
return src;
}
static uae_u8 *restore_key (UnitInfo *ui, Unit *u, uae_u8 *src)
{
int uniq;
TCHAR *p, *pn;
mode_t openmode;
int err;
int missing;
a_inode *a;
Key *k;
uae_u64 savedsize, size, pos;
missing = 0;
k = xcalloc (Key, 1);
k->uniq = restore_u64 ();
k->file_pos = restore_u32 ();
k->createmode = restore_u32 ();
k->dosmode = restore_u32 ();
savedsize = restore_u32 ();
uniq = restore_u64 ();
p = restore_string ();
pos = restore_u64 ();
size = restore_u64 ();
if (size) {
savedsize = size;
k->file_pos = pos;
}
pn = makenativepath (ui, p);
openmode = ((k->dosmode & A_FIBF_READ) == 0 ? O_WRONLY
: (k->dosmode & A_FIBF_WRITE) == 0 ? O_RDONLY
: O_RDWR);
write_log (_T("FS: open file '%s' ('%s'), pos=%llu\n"), p, pn, k->file_pos);
a = get_aino (u, &u->rootnode, p, &err);
if (!a)
write_log (_T("*** FS: Open file aino creation failed '%s'\n"), p);
missing = 1;
if (a) {
missing = 0;
k->aino = a;
if (a->uniq != uniq)
write_log (_T("*** FS: Open file '%s' aino id %d != %d\n"), p, uniq, a->uniq);
if (!my_existsfile (pn)) {
write_log (_T("*** FS: Open file '%s' is missing, creating dummy file!\n"), p);
if (savedsize < 10 * 1024 * 1024) {
k->fd = fs_openfile (u, a, openmode | O_CREAT |O_BINARY);
if (k->fd) {
uae_u8 *buf = xcalloc (uae_u8, 10000);
uae_u64 sp = savedsize;
while (sp) {
uae_u32 s = sp >= 10000 ? 10000 : sp;
fs_write (k->fd, buf, s);
sp -= s;
}
xfree(buf);
write_log (_T("*** FS: dummy file created\n"));
} else {
write_log (_T("*** FS: Open file '%s', couldn't create dummy file!\n"), p);
}
} else {
write_log (_T("*** FS: Too big, ignored\n"));
}
} else {
k->fd = fs_openfile (u, a, openmode | O_BINARY);
}
if (!k->fd) {
write_log (_T("*** FS: Open file '%s' failed to open!\n"), p);
missing = 1;
} else {
uae_s64 s;
s = key_filesize(k);
if (s != savedsize)
write_log (_T("FS: restored file '%s' size changed! orig=%llu, now=%lld!!\n"), p, savedsize, s);
if (k->file_pos > s) {
write_log (_T("FS: restored filepos larger than size of file '%s'!! %llu > %lld\n"), p, k->file_pos, s);
k->file_pos = s;
}
key_seek(k, k->file_pos, SEEK_SET);
}
}
xfree (p);
if (missing) {
xfree (k);
} else {
k->next = u->keys;
u->keys = k;
}
return src;
}
static uae_u8 *restore_notify (UnitInfo *ui, Unit *u, uae_u8 *src)
{
Notify *n = xcalloc (Notify, 1);
uae_u32 hash;
TCHAR *s;
n->notifyrequest = restore_u32 ();
s = restore_string ();
n->fullname = xmalloc (TCHAR, _tcslen (ui->volname) + 2 + _tcslen (s) + 1);
_stprintf (n->fullname, _T("%s:%s"), ui->volname, s);
xfree(s);
s = _tcsrchr (n->fullname, '/');
if (s)
s++;
else
s = n->fullname;
n->partname = my_strdup (s);
hash = notifyhash (n->fullname);
n->next = u->notifyhash[hash];
u->notifyhash[hash] = n;
write_log (_T("FS: notify %08X '%s' '%s'\n"), n->notifyrequest, n->fullname, n->partname);
return src;
}
static uae_u8 *restore_exkey (UnitInfo *ui, Unit *u, uae_u8 *src)
{
restore_u64 ();
restore_u64 ();
restore_u64 ();
return src;
}
static uae_u8 *restore_filesys_virtual (UnitInfo *ui, uae_u8 *src, int num)
{
Unit *u = startup_create_unit (ui, num);
int cnt;
u->dosbase = restore_u32 ();
u->volume = restore_u32 ();
u->port = restore_u32 ();
u->locklist = restore_u32 ();
u->dummy_message = restore_u32 ();
u->cmds_sent = restore_u64 ();
u->cmds_complete = restore_u64 ();
u->cmds_acked = restore_u64 ();
u->next_exkey = restore_u32 ();
u->total_locked_ainos = restore_u32 ();
u->volflags = ui->volflags;
cnt = restore_u32 ();
write_log (_T("FS: restoring %d locks\n"), cnt);
while (cnt-- > 0)
src = restore_aino (ui, u, src);
cnt = restore_u32 ();
write_log (_T("FS: restoring %d open files\n"), cnt);
while (cnt-- > 0)
src = restore_key (ui, u, src);
cnt = restore_u32 ();
write_log (_T("FS: restoring %d notifications\n"), cnt);
while (cnt-- > 0)
src = restore_notify (ui, u, src);
cnt = restore_u32 ();
write_log (_T("FS: restoring %d exkeys\n"), cnt);
while (cnt-- > 0)
src = restore_exkey (ui, u, src);
return src;
}
static TCHAR *getfullaname (a_inode *a)
{
TCHAR *p;
int first = 1;
p = xcalloc (TCHAR, MAX_DPATH);
while (a) {
int len = _tcslen (a->aname);
memmove (p + len + 1, p, (_tcslen (p) + 1) * sizeof (TCHAR));
memcpy (p, a->aname, len * sizeof (TCHAR));
if (!first)
p[len] = '/';
first = 0;
a = a->parent;
if (a && a->uniq == 0)
return p;
}
return p;
}
/* scan and save all Lock()'d files */
static int recurse_aino (UnitInfo *ui, a_inode *a, int cnt, uae_u8 **dstp)
{
uae_u8 *dst = NULL;
int dirty = 0;
a_inode *a2 = a;
if (dstp)
dst = *dstp;
while (a) {
//write_log("recurse '%s' '%s' %d %08x\n", a->aname, a->nname, a->uniq, a->parent);
if (a->elock || a->shlock || a->uniq == 0) {
if (dst) {
TCHAR *fn = NULL;
write_log (_T("uniq=%d %lld s=%d e=%d d=%d '%s' '%s'\n"), a->uniq, a->uniq_external, a->shlock, a->elock, a->dir, a->aname, a->nname);
if (a->aname) {
fn = getfullaname (a);
write_log (_T("->'%s'\n"), fn);
}
save_u64 (a->uniq);
save_u32 (a->locked_children);
save_u32 (a->exnext_count);
save_u32 (a->shlock);
save_u32 ((a->elock ? 1 : 0) | (a->dir ? 2 : 0) | 4);
save_u64 (a->uniq_external);
save_string (fn);
xfree(fn);
}
cnt++;
}
if (a->dirty)
dirty = 1;
if (a->child)
cnt = recurse_aino (ui, a->child, cnt, &dst);
a = a->sibling;
}
if (dirty && a2->parent)
fsdb_dir_writeback (a2->parent);
if (dst)
*dstp = dst;
return cnt;
}
static uae_u8 *save_key (uae_u8 *dst, Key *k)
{
TCHAR *fn = getfullaname (k->aino);
uae_u64 size;
save_u64 (k->uniq);
save_u32 ((uae_u32)k->file_pos);
save_u32 (k->createmode);
save_u32 (k->dosmode);
size = fs_fsize (k->fd);
save_u32 ((uae_u32)size);
save_u64 (k->aino->uniq);
save_string (fn);
save_u64 (k->file_pos);
save_u64 (size);
write_log (_T("'%s' uniq=%d size=%lld seekpos=%lld mode=%d dosmode=%d\n"),
fn, k->uniq, size, k->file_pos, k->createmode, k->dosmode);
xfree (fn);
return dst;
}
static uae_u8 *save_notify (UnitInfo *ui, uae_u8 *dst, Notify *n)
{
TCHAR *s;
save_u32 (n->notifyrequest);
s = n->fullname;
if (_tcslen (s) >= _tcslen (ui->volname) && !_tcsncmp (n->fullname, ui->volname, _tcslen (ui->volname)))
s = n->fullname + _tcslen (ui->volname) + 1;
save_string (s);
write_log (_T("FS: notify %08X '%s'\n"), n->notifyrequest, n->fullname);
return dst;
}
static uae_u8 *save_exkey (uae_u8 *dst, ExamineKey *ek)
{
save_u64 (ek->uniq);
save_u64 (ek->aino->uniq);
save_u64 (ek->curr_file->uniq);
return dst;
}
static uae_u8 *save_filesys_virtual (UnitInfo *ui, uae_u8 *dst)
{
Unit *u = ui->self;
Key *k;
int cnt, i, j;
write_log (_T("FSSAVE: '%s'\n"), ui->devname);
save_u32 (u->dosbase);
save_u32 (u->volume);
save_u32 (u->port);
save_u32 (u->locklist);
save_u32 (u->dummy_message);
save_u64 (u->cmds_sent);
save_u64 (u->cmds_complete);
save_u64 (u->cmds_acked);
save_u32 (u->next_exkey);
save_u32 (u->total_locked_ainos);
cnt = recurse_aino (ui, &u->rootnode, 0, NULL);
save_u32 (cnt);
write_log (_T("%d open locks\n"), cnt);
cnt = recurse_aino (ui, &u->rootnode, 0, &dst);
cnt = 0;
for (k = u->keys; k; k = k->next)
cnt++;
save_u32 (cnt);
write_log (_T("%d open files\n"), cnt);
for (k = u->keys; k; k = k->next)
dst = save_key (dst, k);
for (j = 0; j < 2; j++) {
cnt = 0;
for (i = 0; i < NOTIFY_HASH_SIZE; i++) {
Notify *n = u->notifyhash[i];
while (n) {
if (j > 0)
dst = save_notify (ui, dst, n);
cnt++;
n = n->next;
}
}
if (j == 0) {
save_u32 (cnt);
write_log (_T("%d notify requests\n"), cnt);
}
}
for (j = 0; j < 2; j++) {
cnt = 0;
for (i = 0; i < EXKEYS; i++) {
ExamineKey *ek = &u->examine_keys[i];
if (ek->uniq) {
cnt++;
if (j > 0)
dst = save_exkey (dst, ek);
}
}
if (j == 0) {
save_u32 (cnt);
write_log (_T("%d exkeys\n"), cnt);
}
}
write_log (_T("END\n"));
return dst;
}
uae_u8 *save_filesys_common (int *len)
{
uae_u8 *dstbak, *dst;
if (nr_units () == 0)
return NULL;
dstbak = dst = xmalloc (uae_u8, 1000);
save_u32 (2);
save_u64 (a_uniq);
save_u64 (key_uniq);
*len = dst - dstbak;
return dstbak;
}
uae_u8 *restore_filesys_common (uae_u8 *src)
{
if (restore_u32 () != 2)
return src;
cd_unit_offset = MAX_FILESYSTEM_UNITS;
cd_unit_number = 0;
filesys_prepare_reset2 ();
filesys_reset2 ();
a_uniq = restore_u64 ();
key_uniq = restore_u64 ();
return src;
}
uae_u8 *save_filesys (int num, int *len)
{
uae_u8 *dstbak, *dst;
UnitInfo *ui;
int type = is_hardfile (num);
ui = &mountinfo.ui[num];
if (ui->open <= 0)
return NULL;
/* not initialized yet, do not save */
if ((type == FILESYS_VIRTUAL || type == FILESYS_CD) && ui->self == NULL)
return NULL;
write_log (_T("FS_FILESYS: '%s' '%s'\n"), ui->devname, ui->volname ? ui->volname : _T("<no name>"));
dstbak = dst = xmalloc (uae_u8, 100000);
save_u32 (2); /* version */
save_u32 (ui->devno);
save_u16 (type);
if (type == FILESYS_VIRTUAL || type == FILESYS_CD)
save_path (ui->rootdir, SAVESTATE_PATH_VDIR);
else if (type == FILESYS_HARDFILE || type == FILESYS_HARDFILE_RDB)
save_path (ui->rootdir, SAVESTATE_PATH_HDF);
else if (type == FILESYS_HARDDRIVE)
save_path (ui->rootdir, SAVESTATE_PATH_HD);
else
save_path (ui->rootdir, SAVESTATE_PATH);
save_string (ui->devname);
save_string (ui->volname);
save_path (ui->filesysdir, SAVESTATE_PATH);
save_u8 (ui->bootpri);
save_u8 (ui->readonly);
save_u32 (ui->startup);
save_u32 (filesys_configdev);
if (type == FILESYS_VIRTUAL || type == FILESYS_CD)
dst = save_filesys_virtual (ui, dst);
if (type == FILESYS_HARDFILE || type == FILESYS_HARDFILE_RDB)
dst = save_filesys_hardfile (ui, dst);
*len = dst - dstbak;
return dstbak;
}
uae_u8 *restore_filesys (uae_u8 *src)
{
int type, devno;
UnitInfo *ui;
TCHAR *devname = 0, *volname = 0, *rootdir = 0, *filesysdir = 0;
uae_u32 startup;
struct uaedev_config_info *ci;
if (restore_u32 () != 2)
return src;
devno = restore_u32 ();
ui = &mountinfo.ui[devno];
ci = &ui->hf.ci;
uci_set_defaults (ci, false);
type = restore_u16 ();
if (type == FILESYS_VIRTUAL) {
rootdir = restore_path (SAVESTATE_PATH_VDIR);
} else if (type == FILESYS_CD) {
rootdir = restore_path (SAVESTATE_PATH_VDIR);
if (cd_unit_offset == MAX_FILESYSTEM_UNITS)
cd_unit_offset = devno;
cd_unit_number++;
} else if (type == FILESYS_HARDFILE || type == FILESYS_HARDFILE_RDB) {
rootdir = restore_path (SAVESTATE_PATH_HDF);
} else if (type == FILESYS_HARDDRIVE) {
rootdir = restore_path (SAVESTATE_PATH_HD);
} else {
rootdir = restore_path (SAVESTATE_PATH);
}
devname = restore_string ();
volname = restore_string ();
filesysdir = restore_path (SAVESTATE_PATH);
ci->bootpri = restore_u8 ();
ci->readonly = restore_u8 () != 0;
startup = restore_u32 ();
filesys_configdev = restore_u32 ();
if (type == FILESYS_HARDFILE || type == FILESYS_HARDFILE_RDB) {
src = restore_filesys_hardfile (ui, src);
xfree (volname);
volname = NULL;
}
_tcscpy (ci->rootdir, rootdir);
_tcscpy (ci->devname, devname);
_tcscpy (ci->volname, volname ? volname : _T(""));
_tcscpy (ci->filesys, filesysdir);
if (set_filesys_unit (devno, ci) < 0) {
write_log (_T("filesys '%s' failed to restore\n"), rootdir);
goto end;
}
ui->devno = devno;
ui->startup = startup;
if (type == FILESYS_VIRTUAL || type == FILESYS_CD)
src = restore_filesys_virtual (ui, src, devno);
write_log (_T("'%s' restored\n"), rootdir);
end:
xfree (rootdir);
xfree (devname);
xfree (volname);
xfree (filesysdir);
return src;
}
int save_filesys_cando (void)
{
if (nr_units () == 0)
return -1;
return filesys_in_interrupt ? 0 : 1;
}
| [
"twilen@winuae.net"
] | twilen@winuae.net |
90a10d9882e65fa8b6afa4e3ef90ecead112e441 | 85a90519c644098eba8cca252449ee54ab22e458 | /cpp/opengl_game/0.3.7/src/iichan/iichan_dialog.cpp | 0b1e068e81d370700e93791fb371db7a2fc9d08a | [] | no_license | fcccode/interview-1 | 17b492dacc20aae489bb2aabddc8f36268b36cc8 | 6db7c1999359905d3f791cde09b8e252112d6354 | refs/heads/master | 2020-04-29T11:40:19.471532 | 2012-05-11T13:52:07 | 2012-05-11T13:52:07 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,885 | cpp | #include "stdafx.h"
#include "../osl/osl_types.h"
#include "../osl/osl_lexems.h"
#include "../osl/osl_parse.h"
#include "../osl/osl_misc.h"
#include "../osl/osl.h"
#include "../misc.h"
#include "iichan_dialog.h"
extern unsigned int OSL_CURRENT_LINE;
vector<DIALOG> dialogs;
bool LoadDialog(const char* file_name)
{
char* str = NULL;
vector<OSL_LEXEM> lxm;
bool ok = false;
int lxm_count = 0;
#ifdef _DEBUG_OSL
WriteToLog(DEFAULT_OSL_LOG_NAME, "Loading dialog file: " + string(file_name));
WriteToLog(DEFAULT_OSL_LOG_NAME, "Input...");
#endif
ok = osl_Input(file_name, &str);
if(ok)
{
#ifdef _DEBUG_OSL
WriteToLog(DEFAULT_OSL_LOG_NAME, "Input OK");
#endif
}
else
{
WriteToLog(DEFAULT_OSL_LOG_NAME, "Input FAILED");
return false;
}
#ifdef _DEBUG_OSL
WriteToLog(DEFAULT_OSL_LOG_NAME, "Lexemize...");
#endif
lxm_count = osl_Lexemize(str, &lxm);
lxm_count > 0 ? ok = true : ok = false;
if(ok)
{
#ifdef _DEBUG_OSL
char buffer[64];
sprintf(buffer, "Lexemize OK (%u lexems token)", lxm_count);
WriteToLog(DEFAULT_OSL_LOG_NAME, buffer);
#endif
delete[] str;
}
else
{
WriteToLog(DEFAULT_OSL_LOG_NAME, "Lexemize FAILED");
return false;
}
#ifdef _DEBUG_OSL
osl_dDumpLexemStream(&lxm);
#endif
#ifdef _DEBUG_OSL
WriteToLog(DEFAULT_OSL_LOG_NAME, "Building dialog");
#endif
DIALOG dialog;
char* name = new char[strlen(NameFromPath(string(file_name)).c_str())+1];
sprintf(name, "%s", NameFromPath(string(file_name)).c_str());
dialog.SetName(name);
vector<OSL_LEXEM> sqm;
for(vector<OSL_LEXEM>::iterator it = lxm.begin();
it != lxm.end();
it++)
{
if(!osl_IsSys((*it).token))
sqm.push_back((*it));
else
OSL_CURRENT_LINE++;
if(osl_IsSemicolon((*it).token))
{
if(sqm.size() != 10)
{
WriteToLog(DEFAULT_OSL_LOG_NAME, "LoadDialog() error: invalid line");
}
else
{
#ifdef _DEBUG_OSL
osl_dDumpLexemStream(&sqm);
#endif
if(!(osl_IsStrConstant(sqm[0].token) && osl_IsIntConstant(sqm[2].token) &&
osl_IsIntConstant(sqm[4].token) && osl_IsStrConstant(sqm[6].token) &&
osl_IsStrConstant(sqm[8].token)))
{
osl_Error("LoadDialog() error: invalid tokens");
}
else
{
DIALOG_MESSAGE message;
message.name = osl_RemoveQuotesStr(sqm[0].token);
message.turn = osl_StrToInt(sqm[2].token);
message.time = osl_StrToInt(sqm[4].token);
message.resource = osl_RemoveQuotesStr(sqm[6].token);
message.text = osl_RemoveQuotesStr(sqm[8].token);
dialog.AddMessage(message);
sqm.clear();
}
}
}
}
dialogs.push_back(dialog);
#ifdef _DEBUG_OSL
WriteToLog(DEFAULT_OSL_LOG_NAME, "Dialog successfully loaded");
#endif
return true;
}
DIALOG* DialogByName(char* name)
{
for(vector<DIALOG>::iterator it = dialogs.begin();
it != dialogs.end();
it++)
{
DIALOG* d = &(*it);
if(strcmp(d->GetName(), name) == 0)
return d;
}
return NULL;
} | [
"enderstd@gmail.com"
] | enderstd@gmail.com |
3937fce76fb785c5e5a78d50c78bc4712dc30d43 | ddf5e34aaf5bd46b8a9c9a5575792c4750b7ed43 | /ref_src/basisfield/dctfield.h | 00fe8ec6243e89c01c6b4f89c8975e96b4f656eb | [] | no_license | chengyu89527/MRI_Registrator | ba989ceb385ec6b5e616777c460f7793258eb216 | dea24a2d3fe6a3c85677e1b77bd64107df05a82b | refs/heads/master | 2020-11-23T19:08:44.132184 | 2019-12-15T10:01:04 | 2019-12-15T10:01:04 | 227,782,024 | 2 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 13,921 | h | // Declarations of class dctfield
//
// dctfield.h
//
// Jesper Andersson, FMRIB Image Analysis Group
//
// Copyright (C) 2007 University of Oxford
//
/* Part of FSL - FMRIB's Software Library
http://www.fmrib.ox.ac.uk/fsl
fsl@fmrib.ox.ac.uk
Developed at FMRIB (Oxford Centre for Functional Magnetic Resonance
Imaging of the Brain), Department of Clinical Neurology, Oxford
University, Oxford, UK
LICENCE
FMRIB Software Library, Release 6.0 (c) 2018, The University of
Oxford (the "Software")
The Software remains the property of the Oxford University Innovation
("the University").
The Software is distributed "AS IS" under this Licence solely for
non-commercial use in the hope that it will be useful, but in order
that the University as a charitable foundation protects its assets for
the benefit of its educational and research purposes, the University
makes clear that no condition is made or to be implied, nor is any
warranty given or to be implied, as to the accuracy of the Software,
or that it will be suitable for any particular purpose or for use
under any specific conditions. Furthermore, the University disclaims
all responsibility for the use which is made of the Software. It
further disclaims any liability for the outcomes arising from using
the Software.
The Licensee agrees to indemnify the University and hold the
University harmless from and against any and all claims, damages and
liabilities asserted by third parties (including claims for
negligence) which arise directly or indirectly from the use of the
Software or the sale of any products based on the Software.
No part of the Software may be reproduced, modified, transmitted or
transferred in any form or by any means, electronic or mechanical,
without the express permission of the University. The permission of
the University is not required if the said reproduction, modification,
transmission or transference is done without financial return, the
conditions of this Licence are imposed upon the receiver of the
product, and all original and amended source code is included in any
transmitted product. You may be held legally responsible for any
copyright infringement that is caused or encouraged by your failure to
abide by these terms and conditions.
You are not permitted under this Licence to use this Software
commercially. Use for which any financial return is received shall be
defined as commercial use, and includes (1) integration of all or part
of the source code or the Software into a product for sale or license
by or on behalf of Licensee to third parties or (2) use of the
Software or any derivative of it for research with the final aim of
developing software products for sale or license to a third party or
(3) use of the Software or any derivative of it for research with the
final aim of developing non-software products for sale or license to a
third party, or (4) use of the Software to provide any service to an
external organisation for which payment is received. If you are
interested in using the Software commercially, please contact Oxford
University Innovation ("OUI"), the technology transfer company of the
University, to negotiate a licence. Contact details are:
fsl@innovation.ox.ac.uk quoting Reference Project 9564, FSL.*/
//
#ifndef dctfield_h
#define dctfield_h
#include <string>
#include <vector>
#include <boost/shared_ptr.hpp>
#include "newmat.h"
#include "miscmaths/bfmatrix.h"
#include "splines.h"
#include "basisfield.h"
namespace BASISFIELD {
static const double PI = 3.141592653589793;
class dctfield: public basisfield
{
private:
// Think of dctbas as a vector of vectors of matrices that define
// the DCT basis set. The first index indicate direction (i.e. x-
// y- or z-direction). The second index indicates derivative, i.e.
// 0th, 1st or 2nd order derivative. E.g. *(dctbas[1][0]) is of
// type Matrix and is the 0th order derivative of the DCT basis
// set for the y-direction.
std::vector<std::vector<boost::shared_ptr<NEWMAT::Matrix> > > dctbas; // DCT basis in the x-, y- and z-directions
// Functions for internal use
boost::shared_ptr<NEWMAT::Matrix> make_dctbas(unsigned int size, unsigned int order, unsigned int deriv=0) const;
void AkBkCxb(const NEWMAT::Matrix& A,
const NEWMAT::Matrix& B,
const NEWMAT::Matrix& C,
const NEWMAT::ColumnVector& b,
NEWMAT::ColumnVector& ret) const;
void AtA(const NEWMAT::Matrix& Bx,
const NEWMAT::Matrix& By,
const NEWMAT::Matrix& Bz,
const NEWMAT::ColumnVector& ima,
NEWMAT::Matrix& AtA) const;
void one_slice_AtA(const NEWMAT::Matrix& Bx,
const NEWMAT::Matrix& By,
const double *ima,
double *AtA) const;
void AtB(const NEWMAT::Matrix& Ax,
const NEWMAT::Matrix& Ay,
const NEWMAT::Matrix& Az,
const NEWMAT::Matrix& Bx,
const NEWMAT::Matrix& By,
const NEWMAT::Matrix& Bz,
const NEWMAT::ColumnVector& ima,
NEWMAT::Matrix& AtB) const;
void one_slice_AtB(const NEWMAT::Matrix& Ax,
const NEWMAT::Matrix& Ay,
const NEWMAT::Matrix& Bx,
const NEWMAT::Matrix& By,
const double *ima,
double *AtB) const;
void memen_H(NEWMAT::DiagonalMatrix& mH) const;
protected:
// Functions for use in this and derived classes
virtual void assign_dctfield(const dctfield& inf);
public:
// Constructors and destructors, including assignment
dctfield(const std::vector<unsigned int>& psz, const std::vector<double>& pvxs, const std::vector<unsigned int>& order);
dctfield(const dctfield& inf);
dctfield& operator=(const dctfield& inf);
virtual ~dctfield() {} // This should drop straight through to base-class
bool valid_size(unsigned int psz, double pvxs, unsigned int porder, unsigned int pdim) const;
// Explicit instruction to compiler that we intend not to refine some Peek functions
using basisfield::Peek;
// Getting the value for a non-integer voxel location
virtual double Peek(double x, double y, double z, FieldIndex fi=FIELD) const {return(0.0);}
// General utility functions
virtual unsigned int CoefSz_x() const {return(static_cast<unsigned int>(dctbas[0][0]->Ncols()));}
virtual unsigned int CoefSz_y() const {return(static_cast<unsigned int>(dctbas[1][0]->Ncols()));}
virtual unsigned int CoefSz_z() const {return(static_cast<unsigned int>(dctbas[2][0]->Ncols()));}
virtual bool HasGlobalSupport() const {return(true);}
// Functions that actually do some work
virtual void SetToConstant(double fv);
virtual void RangeOfBasesWithSupportAtXyz(const NEWMAT::ColumnVector& xyz,
std::vector<unsigned int>& first,
std::vector<unsigned int>& last) const
{
first[0] = first[1] = first[2] = 0;
last[0] = CoefSz_x(); last[1] = CoefSz_y(); last[2] = CoefSz_z();
}
// Get the value of basis lmn at point xyz
virtual double ValueOfBasisLmnAtXyz(const std::vector<unsigned int>& lmn,
const NEWMAT::ColumnVector& xyz) const
{
return(0);
}
virtual std::vector<double> SubsampledVoxelSize(unsigned int ss,
std::vector<double> vxs = std::vector<double>(),
std::vector<unsigned int> ms = std::vector<unsigned int>()) const
{
std::vector<unsigned int> ssv(NDim(),ss);
return(SubsampledVoxelSize(ssv,vxs,ms));
}
virtual std::vector<double> SubsampledVoxelSize(const std::vector<unsigned int>& ss,
std::vector<double> vxs = std::vector<double>(),
std::vector<unsigned int> ms = std::vector<unsigned int>()) const;
virtual std::vector<unsigned int> SubsampledMatrixSize(unsigned int ss,
std::vector<unsigned int> ms = std::vector<unsigned int>()) const
{
std::vector<unsigned int> ssv(NDim(),ss);
return(SubsampledMatrixSize(ssv,ms));
}
virtual std::vector<unsigned int> SubsampledMatrixSize(const std::vector<unsigned int>& ss,
std::vector<unsigned int> ms = std::vector<unsigned int>()) const;
virtual void Update(FieldIndex fi);
virtual NEWMAT::ReturnMatrix Jte(const NEWIMAGE::volume<float>& ima1,
const NEWIMAGE::volume<float>& ima2,
const NEWIMAGE::volume<char> *mask) const;
virtual NEWMAT::ReturnMatrix Jte(const std::vector<unsigned int>& deriv,
const NEWIMAGE::volume<float>& ima1,
const NEWIMAGE::volume<float>& ima2,
const NEWIMAGE::volume<char> *mask) const;
virtual NEWMAT::ReturnMatrix Jte(const NEWIMAGE::volume<float>& ima,
const NEWIMAGE::volume<char> *mask) const;
virtual NEWMAT::ReturnMatrix Jte(const std::vector<unsigned int>& deriv,
const NEWIMAGE::volume<float>& ima,
const NEWIMAGE::volume<char> *mask) const;
virtual boost::shared_ptr<MISCMATHS::BFMatrix> JtJ(const NEWIMAGE::volume<float>& ima,
const NEWIMAGE::volume<char> *mask,
MISCMATHS::BFMatrixPrecisionType prec) const;
virtual boost::shared_ptr<MISCMATHS::BFMatrix> JtJ(const NEWIMAGE::volume<float>& ima1,
const NEWIMAGE::volume<float>& ima2,
const NEWIMAGE::volume<char> *mask,
MISCMATHS::BFMatrixPrecisionType prec) const;
virtual boost::shared_ptr<MISCMATHS::BFMatrix> JtJ(const std::vector<unsigned int>& deriv,
const NEWIMAGE::volume<float>& ima,
const NEWIMAGE::volume<char> *mask,
MISCMATHS::BFMatrixPrecisionType prec) const;
virtual boost::shared_ptr<MISCMATHS::BFMatrix> JtJ(const std::vector<unsigned int>& deriv,
const NEWIMAGE::volume<float>& ima1,
const NEWIMAGE::volume<float>& ima2,
const NEWIMAGE::volume<char> *mask,
MISCMATHS::BFMatrixPrecisionType prec) const;
virtual boost::shared_ptr<MISCMATHS::BFMatrix> JtJ(const std::vector<unsigned int>& deriv1,
const NEWIMAGE::volume<float>& ima1,
const std::vector<unsigned int>& deriv2,
const NEWIMAGE::volume<float>& ima2,
const NEWIMAGE::volume<char> *mask,
MISCMATHS::BFMatrixPrecisionType prec) const;
virtual boost::shared_ptr<MISCMATHS::BFMatrix> JtJ(const NEWIMAGE::volume<float>& ima1,
const basisfield& bf2,
const NEWIMAGE::volume<float>& ima2,
const NEWIMAGE::volume<char> *mask,
MISCMATHS::BFMatrixPrecisionType prec) const;
virtual double MemEnergy() const;
virtual double BendEnergy() const {throw BasisfieldException("dctfield::BendEnergy not yet implemented"); } // return(0.0);} // nvcc complained
virtual NEWMAT::ReturnMatrix MemEnergyGrad() const;
virtual NEWMAT::ReturnMatrix BendEnergyGrad() const
{
// Matrix skrutt(1,1); // nvcc complained
throw BasisfieldException("dctfield::BendEnergyGrad not yet implemented");
// return(skrutt); // nvcc complained
}
virtual boost::shared_ptr<MISCMATHS::BFMatrix> MemEnergyHess(MISCMATHS::BFMatrixPrecisionType prec) const;
virtual boost::shared_ptr<MISCMATHS::BFMatrix> BendEnergyHess(MISCMATHS::BFMatrixPrecisionType prec) const
{
// boost::shared_ptr<MISCMATHS::BFMatrix> skrutt(new MISCMATHS::FullBFMatrix()); // nvcc complained
throw BasisfieldException("dctfield::BendEnergyHess not yet implemented");
// return(skrutt); // nvcc complained
}
virtual boost::shared_ptr<BASISFIELD::basisfield> ZoomField(const std::vector<unsigned int>& psz,
const std::vector<double>& pvxs,
std::vector<unsigned int> order=std::vector<unsigned int>()) const;
};
} // End namespace BASISFIELD
#endif
| [
"68667194@qq.com"
] | 68667194@qq.com |
1d116d5a8bf218d99fc24c6b5980736ff6b11a4a | a35b30a7c345a988e15d376a4ff5c389a6e8b23a | /boost/geometry/algorithms/detail/overlay/check_enrich.hpp | 2472176af7045970ce19e43ee2977f881092a83f | [] | no_license | huahang/thirdparty | 55d4cc1c8a34eff1805ba90fcbe6b99eb59a7f0b | 07a5d64111a55dda631b7e8d34878ca5e5de05ab | refs/heads/master | 2021-01-15T14:29:26.968553 | 2014-02-06T07:35:22 | 2014-02-06T07:35:22 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 93 | hpp | #include "thirdparty/boost_1_55_0/boost/geometry/algorithms/detail/overlay/check_enrich.hpp"
| [
"liuhuahang@xiaomi.com"
] | liuhuahang@xiaomi.com |
6d8eca5092b17f95477e6acf037d2f3382212a6d | 8a8873b129313b24341e8fa88a49052e09c3fa51 | /inc/DownloadHistoryList.h | e9a693cf53ba8f86b54ef3ddd8b923b14102f8fd | [] | 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 | 2,412 | h | /*
============================================================================
Name : DownloadHistoryList.h
Author : 浮生若茶
Version :
Copyright : Your copyright notice
Description : CDownloadHistoryList declaration
============================================================================
*/
#ifndef DOWNLOADHISTORYLIST_H
#define DOWNLOADHISTORYLIST_H
#include "Control.h"
#include "PopUpMenuObserver.h"
#include "DownLoadHistoryEngine.h"
#include "MControlObserver.h"
#include "DialogObserver.h"
class CMainEngine;
class CListBox;
class CDownloadManagerWindow;
class CDownloadHistoryList : public CControl , public MPopUpMenuObserver , public MDownLoadHistoryNotice , public MInputObserver , public MDialogObserver
{
public: // Constructors and destructor
~CDownloadHistoryList();
static CDownloadHistoryList* NewL(CMainEngine& aMainEngine,CDownloadManagerWindow& aDownloadManagerWindow);
static CDownloadHistoryList* NewLC(CMainEngine& aMainEngine,CDownloadManagerWindow& aDownloadManagerWindow);
private:
CDownloadHistoryList(CMainEngine& aMainEngine,CDownloadManagerWindow& aDownloadManagerWindow);
void ConstructL();
public://From CControl
virtual void Draw(CGraphic& aGraphic)const;
virtual TBool KeyEventL(TInt aKeyCode);
virtual TBool HandleCommandL(TInt aCommand);
virtual void SizeChanged(const TRect& aScreenRect); //待论证
public://From MPopUpMenuObserver
virtual void DoPopUpMenuCommand(TInt aCommand);
public://From MDownLoadHistoryNotice
virtual void Update();
public://From MInputObserver
virtual void InputResponseEvent(TInt aEvent,const TDesC& aText);
public://From MDialogObserver
virtual void DialogEvent(TInt aCommand);
private:
void InitPopUpMenu();
void InitListBox(TInt aPageIndex);
void GetStartPage();
void GetPrePage();
void GetNextPage();
void GetEndPage();
void GotoPage();
void OpenCurFile();
void OpenCurFileWith();
void DelTaskFromList();
void DelTaskFromFile();
void DelAllTaskFromList();
void DelAllTaskFromFile();
private:
CMainEngine& iMainEngine;
CDownloadManagerWindow& iDownloadManagerWindow;
CDownLoadHistoryEngine& iDownLoadHistoryEngine;
CListBox* iListBox;
RArray<TDownLoadHistoryShowInfo> iDownLoadHistoryInfoArray;
TInt iTotalPageNum;
TInt iPageIndex;
};
#endif // DOWNLOADHISTORYLIST_H
| [
"sungrass.xp@37a08ede-ebbd-11dd-bd7b-b12b6590754f"
] | sungrass.xp@37a08ede-ebbd-11dd-bd7b-b12b6590754f |
00e9e10f236d0179e9a804dd780a48343da8dda9 | 6bd9d7679011042f46104d97080786423ae58879 | /1277/a/a.cc | 48869410803bacc92fe95ca2df278868d2a03c0a | [
"CC-BY-4.0"
] | permissive | lucifer1004/codeforces | 20b77bdd707a1e04bc5b1230f5feb4452d5f4c78 | d1fe331d98d6d379723939db287a499dff24c519 | refs/heads/master | 2023-04-28T16:00:37.673566 | 2023-04-17T03:40:27 | 2023-04-17T03:40:27 | 212,258,015 | 3 | 1 | null | 2020-10-27T06:54:02 | 2019-10-02T04:53:36 | C++ | UTF-8 | C++ | false | false | 620 | cc | #include <algorithm>
#include <bitset>
#include <climits>
#include <cmath>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
typedef long long ll;
class Solution {
public:
void solve() {
ll n;
cin >> n;
ll ans = 0, div = 1;
while (n >= div) {
ans += min(n / div, 9ll);
div = div * 10ll + 1ll;
}
cout << ans << endl;
}
};
int main() {
int t;
cin >> t;
while (t--) {
Solution solution = Solution();
solution.solve();
}
} | [
"wuzihua@pku.edu.cn"
] | wuzihua@pku.edu.cn |
b1779e94e9402923c3eb62f48797cb0a588bf3dd | 702191129549fb9e28ed327b9eed344218e82496 | /Problems/programmers_여행경로/programmers_여행경로.cpp | c14c0ea798ecf2f40f5b8b5a1d0eff8b2bf2a5d4 | [] | no_license | Sunjae95/BOJ-Algorithm-Study | 219997490c5098a34e7b9d008070e0799345ac92 | 8154101bd1c4b2ab0cea957f8bd7594d569cb517 | refs/heads/master | 2022-12-30T17:47:10.473181 | 2020-10-20T15:34:11 | 2020-10-20T15:34:11 | null | 0 | 0 | null | null | null | null | UHC | C++ | false | false | 919 | cpp | #include <string>
#include <vector>
#include <map>
#include <algorithm>
using namespace std;
const int MAX = 10000;
bool visit[MAX + 1];
bool dfs(string node, vector<vector<string>>& tickets, vector<string>& answer, int index) {
answer.push_back(node);
if (index == tickets.size()) { // 모든 티켓을 사용한 경우
return true;
}
for (int i = 0; i < tickets.size(); i++) {
string next = tickets[i][1];
string now = tickets[i][0];
// 다음 출발지가 현재 위치와 일치하는 아직 사용하지 않은 티켓이 있는지 확인
if (now == node && visit[i] == false) {
visit[i] = true;
if (dfs(next, tickets, answer, index + 1)) return true;
visit[i] = false;
}
}
answer.pop_back();
return false;
}
vector<string> solution(vector<vector<string>> tickets) {
vector<string> answer;
sort(tickets.begin(), tickets.end());
dfs("ICN", tickets, answer, 0);
return answer;
} | [
"kyu9341@naver.com"
] | kyu9341@naver.com |
24bb2ec91f9a2b6ccd83972c13f5202bea299528 | b77dd6dcb1f84fc249e0050013e6d74f2b3f039d | /include/floorplan/floorPlan.h | aa075f2b6b2b0ff803fedc5f265393b182681f85 | [] | no_license | 3DTK/3DTK | fad4333832d5ee3c4fa43a0e3c2ab719bd7ec278 | bfc46d1b30b35a955ebde78c229ac40ee10e296c | refs/heads/master | 2023-08-10T01:58:20.472841 | 2023-07-28T11:54:42 | 2023-07-28T11:54:42 | 120,477,018 | 64 | 28 | null | null | null | null | UTF-8 | C++ | false | false | 2,096 | h | /*
* floorPlan.h
*
* Created on: Apr 29, 2013
* Author: rdumitru
*/
#ifndef FLOORPLAN_H_
#define FLOORPLAN_H_
//==============================================================================
// Includes.
//==============================================================================
// OpenCV includes.
#include <opencv2/opencv.hpp>
// C++ includes.
#include <vector>
//==============================================================================
// Class declaration.
//==============================================================================
namespace floorplan {
class FloorPlan {
private:
// Private fields.
cv::Mat grayImg; // the original gray image
cv::Mat thresh; // the thresholded binary image
std::vector<cv::Vec4i> walls; // the walls as lines
double scale; // what does one pixel mean?
// Private static fields.
static const double STD_DEV_MUL; // the coefficient for the standard deviation when thresholding
static const double ANGLE_RES; // the dominant orientation histogram resolution in degrees
static const double HOUGH_RHO; // rho used in the Hough transform
static const double HOUGH_THETA; // theta used in the Hough transform
static const int HOUGH_THRESH; // Hough transform threshold
static const double HOUGH_MIN_LINE_LEN; // minimum line length for Hough transform in cm; we take care of scaling
static const double MAX_ANGLE; // the maximum angle of the orientation histogram
static const double SNAP_ANGLE_THRESH; // angle to consider a line close to a dominant orientation
// Private methods.
std::vector<cv::Vec4i> extractWallLines();
std::vector<int> computeOrientationHist();
void correctWallLines();
protected:
explicit inline FloorPlan() {}
public:
// Constructors.
FloorPlan(const cv::Mat &grayPlan, const double &scale);
FloorPlan(const FloorPlan &other);
~FloorPlan();
};
} /* namespace floorplan */
#endif /* FLOORPLAN_H_ */
| [
"dborrman@users.sourceforge.net"
] | dborrman@users.sourceforge.net |
05cbac084f32d2d4172f95aa6a6fc35bbcbf1421 | a9c2299b54a544ca0a046675c344c43386083be6 | /Elemental/Message/source/MessageInterface.cpp | 36964613b43d411e20ee0c494dcaf71ab861d2f7 | [] | no_license | DBurden1997/Elemental | 0943f6ddf7c7d8520c1903349180f69fddeb6ed8 | 49f45bdaebe0a74cf0155885e43ad4ecf6fb1dcc | refs/heads/master | 2020-04-15T05:22:12.941917 | 2019-01-07T10:44:44 | 2019-01-07T10:44:44 | 164,418,812 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 673 | cpp | //
// MessageInterface.cpp
// Elements
//
// Created by Dylan Burden on 2018-07-14.
// Copyright © 2018 DarkBlaze. All rights reserved.
//
#include "MessageInterface.hpp"
#include "Message.hpp"
#include <stdio.h>
std::vector< MessageInterface* > MessageInterface::receivers;
void MessageInterface::send( Message_Type mesType, IEntity* entity, std::string str, IEntity* entity2, std::string str2 ) {
//Create a new message with the required information
Message newMessage( mesType, entity, str, entity2, str2 );
//Send the message to all receivers
for (int i = 0; i < receivers.size(); i++) {
receivers[i]->receive( newMessage );
}
}
| [
"dylanburden@Dylans-MacBook-Air.local"
] | dylanburden@Dylans-MacBook-Air.local |
d7d01f0e74d34a0f3024f7ea987efb69659a4922 | 24afb5aea2c431f5b74233cdaaa239e857ae5053 | /src/kcftracker_wrap.cxx | 301f030b7dfb301e6496b73832080619258498ca | [] | no_license | AutoRaider/python_gpu_kcf | 32e4d268f5df360f9c67a21e1384102953253724 | d3a139a7770bd84f437ad13c8bfb31e6d5cf7a22 | refs/heads/master | 2020-04-18T02:22:48.851368 | 2018-12-13T02:07:34 | 2018-12-13T02:07:34 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,396,729 | cxx | /* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (http://www.swig.org).
* Version 3.0.8
*
* 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.
* ----------------------------------------------------------------------------- */
#ifndef SWIGPYTHON
#define SWIGPYTHON
#endif
#define SWIG_PYTHON_DIRECTOR_NO_VTABLE
#ifdef __cplusplus
/* SwigValueWrapper is described in swig.swg */
template<typename T> class SwigValueWrapper {
struct SwigMovePointer {
T *ptr;
SwigMovePointer(T *p) : ptr(p) { }
~SwigMovePointer() { delete ptr; }
SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
} pointer;
SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
SwigValueWrapper(const SwigValueWrapper<T>& rhs);
public:
SwigValueWrapper() : pointer(0) { }
SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
operator T&() const { return *pointer.ptr; }
T *operator&() { return pointer.ptr; }
};
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
/* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
#if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
# define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
#endif
/* Intel's compiler complains if a variable which was never initialised is
* cast to void, which is a common idiom which we use to indicate that we
* are aware a variable isn't used. So we just silence that warning.
* See: https://github.com/swig/swig/issues/192 for more discussion.
*/
#ifdef __INTEL_COMPILER
# pragma warning disable 592
#endif
#if defined(_DEBUG) && defined(SWIG_PYTHON_INTERPRETER_NO_DEBUG)
/* Use debug wrappers with the Python release dll */
# undef _DEBUG
# include <Python.h>
# define _DEBUG
#else
# include <Python.h>
#endif
/* -----------------------------------------------------------------------------
* swigrun.swg
*
* This file contains generic C API 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 strictly necessary, ie, if you have problems
with your compiler or suchlike.
*/
#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 an 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 versions of SWIG, code such as the following was usually written:
if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
// success code
} else {
//fail code
}
Now you can be more explicit:
int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
if (SWIG_IsOK(res)) {
// success code
} else {
// fail code
}
which is the same really, 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
also requires SWIG_ConvertPtr to return new result values, such 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(r) (r)
# 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 equal, -1 if nb < tb, 1 if nb > tb
*/
SWIGRUNTIME int
SWIG_TypeCmp(const char *nb, const char *tb) {
int equiv = 1;
const char* te = tb + strlen(tb);
const char* ne = nb;
while (equiv != 0 && *ne) {
for (nb = ne; *ne; ++ne) {
if (*ne == '|') break;
}
equiv = SWIG_TypeNameComp(nb, ne, tb, te);
if (*ne) ++ne;
}
return equiv;
}
/*
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) {
return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
}
/*
Check the typename
*/
SWIGRUNTIME swig_cast_info *
SWIG_TypeCheck(const char *c, swig_type_info *ty) {
if (ty) {
swig_cast_info *iter = ty->cast;
while (iter) {
if (strcmp(iter->type->name, c) == 0) {
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;
}
/*
Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
*/
SWIGRUNTIME swig_cast_info *
SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) {
if (ty) {
swig_cast_info *iter = ty->cast;
while (iter) {
if (iter->type == from) {
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;
}
/*
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) {
size_t l = 0;
size_t r = iter->size - 1;
do {
/* since l+r >= 0, we can (>> 1) instead (/ 2) */
size_t i = (l + r) >> 1;
const char *iname = iter->types[i]->name;
if (iname) {
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 {
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";
const unsigned char *u = (unsigned char *) ptr;
const unsigned char *eu = u + sz;
for (; u != eu; ++u) {
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) {
unsigned char *u = (unsigned char *) ptr;
const unsigned char *eu = u + sz;
for (; u != eu; ++u) {
char d = *(c++);
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
/* Compatibility macros for Python 3 */
#if PY_VERSION_HEX >= 0x03000000
#define PyClass_Check(obj) PyObject_IsInstance(obj, (PyObject *)&PyType_Type)
#define PyInt_Check(x) PyLong_Check(x)
#define PyInt_AsLong(x) PyLong_AsLong(x)
#define PyInt_FromLong(x) PyLong_FromLong(x)
#define PyInt_FromSize_t(x) PyLong_FromSize_t(x)
#define PyString_Check(name) PyBytes_Check(name)
#define PyString_FromString(x) PyUnicode_FromString(x)
#define PyString_Format(fmt, args) PyUnicode_Format(fmt, args)
#define PyString_AsString(str) PyBytes_AsString(str)
#define PyString_Size(str) PyBytes_Size(str)
#define PyString_InternFromString(key) PyUnicode_InternFromString(key)
#define Py_TPFLAGS_HAVE_CLASS Py_TPFLAGS_BASETYPE
#define PyString_AS_STRING(x) PyUnicode_AS_STRING(x)
#define _PyLong_FromSsize_t(x) PyLong_FromSsize_t(x)
#endif
#ifndef Py_TYPE
# define Py_TYPE(op) ((op)->ob_type)
#endif
/* SWIG APIs for compatibility of both Python 2 & 3 */
#if PY_VERSION_HEX >= 0x03000000
# define SWIG_Python_str_FromFormat PyUnicode_FromFormat
#else
# define SWIG_Python_str_FromFormat PyString_FromFormat
#endif
/* Warning: This function will allocate a new string in Python 3,
* so please call SWIG_Python_str_DelForPy3(x) to free the space.
*/
SWIGINTERN char*
SWIG_Python_str_AsChar(PyObject *str)
{
#if PY_VERSION_HEX >= 0x03000000
char *cstr;
char *newstr;
Py_ssize_t len;
str = PyUnicode_AsUTF8String(str);
PyBytes_AsStringAndSize(str, &cstr, &len);
newstr = (char *) malloc(len+1);
memcpy(newstr, cstr, len+1);
Py_XDECREF(str);
return newstr;
#else
return PyString_AsString(str);
#endif
}
#if PY_VERSION_HEX >= 0x03000000
# define SWIG_Python_str_DelForPy3(x) free( (void*) (x) )
#else
# define SWIG_Python_str_DelForPy3(x)
#endif
SWIGINTERN PyObject*
SWIG_Python_str_FromChar(const char *c)
{
#if PY_VERSION_HEX >= 0x03000000
return PyUnicode_FromString(c);
#else
return PyString_FromString(c);
#endif
}
/* 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
typedef inquiry lenfunc;
typedef intargfunc ssizeargfunc;
typedef intintargfunc ssizessizeargfunc;
typedef intobjargproc ssizeobjargproc;
typedef intintobjargproc ssizessizeobjargproc;
typedef getreadbufferproc readbufferproc;
typedef getwritebufferproc writebufferproc;
typedef getsegcountproc segcountproc;
typedef getcharbufferproc charbufferproc;
static long PyNumber_AsSsize_t (PyObject *x, void *SWIGUNUSEDPARM(exc))
{
long result = 0;
PyObject *i = PyNumber_Int(x);
if (i) {
result = PyInt_AsLong(i);
Py_DECREF(i);
}
return result;
}
#endif
#if PY_VERSION_HEX < 0x02050000
#define PyInt_FromSize_t(x) PyInt_FromLong((long)x)
#endif
#if PY_VERSION_HEX < 0x02040000
#define Py_VISIT(op) \
do { \
if (op) { \
int vret = visit((op), arg); \
if (vret) \
return vret; \
} \
} while (0)
#endif
#if PY_VERSION_HEX < 0x02030000
typedef struct {
PyTypeObject type;
PyNumberMethods as_number;
PyMappingMethods as_mapping;
PySequenceMethods as_sequence;
PyBufferProcs as_buffer;
PyObject *name, *slots;
} PyHeapTypeObject;
#endif
#if PY_VERSION_HEX < 0x02030000
typedef destructor freefunc;
#endif
#if ((PY_MAJOR_VERSION == 2 && PY_MINOR_VERSION > 6) || \
(PY_MAJOR_VERSION == 3 && PY_MINOR_VERSION > 0) || \
(PY_MAJOR_VERSION > 3))
# define SWIGPY_USE_CAPSULE
# define SWIGPY_CAPSULE_NAME ((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION ".type_pointer_capsule" SWIG_TYPE_TABLE_NAME)
#endif
#if PY_VERSION_HEX < 0x03020000
#define PyDescr_TYPE(x) (((PyDescrObject *)(x))->d_type)
#define PyDescr_NAME(x) (((PyDescrObject *)(x))->d_name)
#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) {
char *tmp;
PyObject *old_str = PyObject_Str(value);
PyErr_Clear();
Py_XINCREF(type);
PyErr_Format(type, "%s %s", tmp = SWIG_Python_str_AsChar(old_str), mesg);
SWIG_Python_str_DelForPy3(tmp);
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" {
#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;
/* -----------------------------------------------------------------------------
* Wrapper of PyInstanceMethod_New() used in Python 3
* It is exported to the generated module, used for -fastproxy
* ----------------------------------------------------------------------------- */
#if PY_VERSION_HEX >= 0x03000000
SWIGRUNTIME PyObject* SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func)
{
return PyInstanceMethod_New(func);
}
#else
SWIGRUNTIME PyObject* SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *SWIGUNUSEDPARM(func))
{
return NULL;
}
#endif
#ifdef __cplusplus
}
#endif
/* -----------------------------------------------------------------------------
* 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)
#ifdef SWIGPYTHON_BUILTIN
#define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(self, ptr, type, flags)
#else
#define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
#endif
#define SWIG_InternalNewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, 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(NULL, 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(clientdata)
#define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
#define SWIG_NewClientData(obj) SwigPyClientData_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, 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 */
#if defined(SWIGPYTHON_BUILTIN)
SWIGINTERN void
SwigPyBuiltin_AddPublicSymbol(PyObject *seq, const char *key) {
PyObject *s = PyString_InternFromString(key);
PyList_Append(seq, s);
Py_DECREF(s);
}
SWIGINTERN void
SWIG_Python_SetConstant(PyObject *d, PyObject *public_interface, const char *name, PyObject *obj) {
#if PY_VERSION_HEX < 0x02030000
PyDict_SetItemString(d, (char *)name, obj);
#else
PyDict_SetItemString(d, name, obj);
#endif
Py_DECREF(obj);
if (public_interface)
SwigPyBuiltin_AddPublicSymbol(public_interface, name);
}
#else
SWIGINTERN void
SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
#if PY_VERSION_HEX < 0x02030000
PyDict_SetItemString(d, (char *)name, obj);
#else
PyDict_SetItemString(d, name, obj);
#endif
Py_DECREF(obj);
}
#endif
/* 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 Py_ssize_t
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)) {
if (min <= 1 && max >= 1) {
Py_ssize_t i;
objs[0] = args;
for (i = 1; i < max; ++i) {
objs[i] = 0;
}
return 2;
}
PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
return 0;
} else {
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 {
Py_ssize_t 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)
#define SWIG_BUILTIN_TP_INIT (SWIG_POINTER_OWN << 2)
#define SWIG_BUILTIN_INIT (SWIG_BUILTIN_TP_INIT | SWIG_POINTER_OWN)
#ifdef __cplusplus
extern "C" {
#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;
}
/* SwigPyClientData */
typedef struct {
PyObject *klass;
PyObject *newraw;
PyObject *newargs;
PyObject *destroy;
int delargs;
int implicitconv;
PyTypeObject *pytype;
} SwigPyClientData;
SWIGRUNTIMEINLINE int
SWIG_Python_CheckImplicit(swig_type_info *ty)
{
SwigPyClientData *data = (SwigPyClientData *)ty->clientdata;
return data ? data->implicitconv : 0;
}
SWIGRUNTIMEINLINE PyObject *
SWIG_Python_ExceptionType(swig_type_info *desc) {
SwigPyClientData *data = desc ? (SwigPyClientData *) desc->clientdata : 0;
PyObject *klass = data ? data->klass : 0;
return (klass ? klass : PyExc_RuntimeError);
}
SWIGRUNTIME SwigPyClientData *
SwigPyClientData_New(PyObject* obj)
{
if (!obj) {
return 0;
} else {
SwigPyClientData *data = (SwigPyClientData *)malloc(sizeof(SwigPyClientData));
/* 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;
data->pytype = 0;
return data;
}
}
SWIGRUNTIME void
SwigPyClientData_Del(SwigPyClientData *data) {
Py_XDECREF(data->newraw);
Py_XDECREF(data->newargs);
Py_XDECREF(data->destroy);
}
/* =============== SwigPyObject =====================*/
typedef struct {
PyObject_HEAD
void *ptr;
swig_type_info *ty;
int own;
PyObject *next;
#ifdef SWIGPYTHON_BUILTIN
PyObject *dict;
#endif
} SwigPyObject;
#ifdef SWIGPYTHON_BUILTIN
SWIGRUNTIME PyObject *
SwigPyObject_get___dict__(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
{
SwigPyObject *sobj = (SwigPyObject *)v;
if (!sobj->dict)
sobj->dict = PyDict_New();
Py_INCREF(sobj->dict);
return sobj->dict;
}
#endif
SWIGRUNTIME PyObject *
SwigPyObject_long(SwigPyObject *v)
{
return PyLong_FromVoidPtr(v->ptr);
}
SWIGRUNTIME PyObject *
SwigPyObject_format(const char* fmt, SwigPyObject *v)
{
PyObject *res = NULL;
PyObject *args = PyTuple_New(1);
if (args) {
if (PyTuple_SetItem(args, 0, SwigPyObject_long(v)) == 0) {
PyObject *ofmt = SWIG_Python_str_FromChar(fmt);
if (ofmt) {
#if PY_VERSION_HEX >= 0x03000000
res = PyUnicode_Format(ofmt,args);
#else
res = PyString_Format(ofmt,args);
#endif
Py_DECREF(ofmt);
}
Py_DECREF(args);
}
}
return res;
}
SWIGRUNTIME PyObject *
SwigPyObject_oct(SwigPyObject *v)
{
return SwigPyObject_format("%o",v);
}
SWIGRUNTIME PyObject *
SwigPyObject_hex(SwigPyObject *v)
{
return SwigPyObject_format("%x",v);
}
SWIGRUNTIME PyObject *
#ifdef METH_NOARGS
SwigPyObject_repr(SwigPyObject *v)
#else
SwigPyObject_repr(SwigPyObject *v, PyObject *args)
#endif
{
const char *name = SWIG_TypePrettyName(v->ty);
PyObject *repr = SWIG_Python_str_FromFormat("<Swig Object of type '%s' at %p>", (name ? name : "unknown"), (void *)v);
if (v->next) {
# ifdef METH_NOARGS
PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next);
# else
PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next, args);
# endif
# if PY_VERSION_HEX >= 0x03000000
PyObject *joined = PyUnicode_Concat(repr, nrep);
Py_DecRef(repr);
Py_DecRef(nrep);
repr = joined;
# else
PyString_ConcatAndDel(&repr,nrep);
# endif
}
return repr;
}
SWIGRUNTIME int
SwigPyObject_compare(SwigPyObject *v, SwigPyObject *w)
{
void *i = v->ptr;
void *j = w->ptr;
return (i < j) ? -1 : ((i > j) ? 1 : 0);
}
/* Added for Python 3.x, would it also be useful for Python 2.x? */
SWIGRUNTIME PyObject*
SwigPyObject_richcompare(SwigPyObject *v, SwigPyObject *w, int op)
{
PyObject* res;
if( op != Py_EQ && op != Py_NE ) {
Py_INCREF(Py_NotImplemented);
return Py_NotImplemented;
}
res = PyBool_FromLong( (SwigPyObject_compare(v, w)==0) == (op == Py_EQ) ? 1 : 0);
return res;
}
SWIGRUNTIME PyTypeObject* SwigPyObject_TypeOnce(void);
#ifdef SWIGPYTHON_BUILTIN
static swig_type_info *SwigPyObject_stype = 0;
SWIGRUNTIME PyTypeObject*
SwigPyObject_type(void) {
SwigPyClientData *cd;
assert(SwigPyObject_stype);
cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
assert(cd);
assert(cd->pytype);
return cd->pytype;
}
#else
SWIGRUNTIME PyTypeObject*
SwigPyObject_type(void) {
static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyObject_TypeOnce();
return type;
}
#endif
SWIGRUNTIMEINLINE int
SwigPyObject_Check(PyObject *op) {
#ifdef SWIGPYTHON_BUILTIN
PyTypeObject *target_tp = SwigPyObject_type();
if (PyType_IsSubtype(op->ob_type, target_tp))
return 1;
return (strcmp(op->ob_type->tp_name, "SwigPyObject") == 0);
#else
return (Py_TYPE(op) == SwigPyObject_type())
|| (strcmp(Py_TYPE(op)->tp_name,"SwigPyObject") == 0);
#endif
}
SWIGRUNTIME PyObject *
SwigPyObject_New(void *ptr, swig_type_info *ty, int own);
SWIGRUNTIME void
SwigPyObject_dealloc(PyObject *v)
{
SwigPyObject *sobj = (SwigPyObject *) v;
PyObject *next = sobj->next;
if (sobj->own == SWIG_POINTER_OWN) {
swig_type_info *ty = sobj->ty;
SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
PyObject *destroy = data ? data->destroy : 0;
if (destroy) {
/* destroy is always a VARARGS method */
PyObject *res;
/* PyObject_CallFunction() has the potential to silently drop
the active active exception. In cases of unnamed temporary
variable or where we just finished iterating over a generator
StopIteration will be active right now, and this needs to
remain true upon return from SwigPyObject_dealloc. So save
and restore. */
PyObject *val = NULL, *type = NULL, *tb = NULL;
PyErr_Fetch(&val, &type, &tb);
if (data->delargs) {
/* we need to create a temporary object to carry the destroy operation */
PyObject *tmp = SwigPyObject_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));
}
if (!res)
PyErr_WriteUnraisable(destroy);
PyErr_Restore(val, type, tb);
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*
SwigPyObject_append(PyObject* v, PyObject* next)
{
SwigPyObject *sobj = (SwigPyObject *) v;
#ifndef METH_O
PyObject *tmp = 0;
if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
next = tmp;
#endif
if (!SwigPyObject_Check(next)) {
PyErr_SetString(PyExc_TypeError, "Attempt to append a non SwigPyObject");
return NULL;
}
sobj->next = next;
Py_INCREF(next);
return SWIG_Py_Void();
}
SWIGRUNTIME PyObject*
#ifdef METH_NOARGS
SwigPyObject_next(PyObject* v)
#else
SwigPyObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
#endif
{
SwigPyObject *sobj = (SwigPyObject *) v;
if (sobj->next) {
Py_INCREF(sobj->next);
return sobj->next;
} else {
return SWIG_Py_Void();
}
}
SWIGINTERN PyObject*
#ifdef METH_NOARGS
SwigPyObject_disown(PyObject *v)
#else
SwigPyObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
#endif
{
SwigPyObject *sobj = (SwigPyObject *)v;
sobj->own = 0;
return SWIG_Py_Void();
}
SWIGINTERN PyObject*
#ifdef METH_NOARGS
SwigPyObject_acquire(PyObject *v)
#else
SwigPyObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
#endif
{
SwigPyObject *sobj = (SwigPyObject *)v;
sobj->own = SWIG_POINTER_OWN;
return SWIG_Py_Void();
}
SWIGINTERN PyObject*
SwigPyObject_own(PyObject *v, PyObject *args)
{
PyObject *val = 0;
#if (PY_VERSION_HEX < 0x02020000)
if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
#elif (PY_VERSION_HEX < 0x02050000)
if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
#else
if (!PyArg_UnpackTuple(args, "own", 0, 1, &val))
#endif
{
return NULL;
}
else
{
SwigPyObject *sobj = (SwigPyObject *)v;
PyObject *obj = PyBool_FromLong(sobj->own);
if (val) {
#ifdef METH_NOARGS
if (PyObject_IsTrue(val)) {
SwigPyObject_acquire(v);
} else {
SwigPyObject_disown(v);
}
#else
if (PyObject_IsTrue(val)) {
SwigPyObject_acquire(v,args);
} else {
SwigPyObject_disown(v,args);
}
#endif
}
return obj;
}
}
#ifdef METH_O
static PyMethodDef
swigobject_methods[] = {
{(char *)"disown", (PyCFunction)SwigPyObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
{(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_NOARGS, (char *)"acquires ownership of the pointer"},
{(char *)"own", (PyCFunction)SwigPyObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
{(char *)"append", (PyCFunction)SwigPyObject_append, METH_O, (char *)"appends another 'this' object"},
{(char *)"next", (PyCFunction)SwigPyObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
{(char *)"__repr__",(PyCFunction)SwigPyObject_repr, METH_NOARGS, (char *)"returns object representation"},
{0, 0, 0, 0}
};
#else
static PyMethodDef
swigobject_methods[] = {
{(char *)"disown", (PyCFunction)SwigPyObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
{(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_VARARGS, (char *)"acquires ownership of the pointer"},
{(char *)"own", (PyCFunction)SwigPyObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
{(char *)"append", (PyCFunction)SwigPyObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
{(char *)"next", (PyCFunction)SwigPyObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
{(char *)"__repr__",(PyCFunction)SwigPyObject_repr, METH_VARARGS, (char *)"returns object representation"},
{0, 0, 0, 0}
};
#endif
#if PY_VERSION_HEX < 0x02020000
SWIGINTERN PyObject *
SwigPyObject_getattr(SwigPyObject *sobj,char *name)
{
return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
}
#endif
SWIGRUNTIME PyTypeObject*
SwigPyObject_TypeOnce(void) {
static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
static PyNumberMethods SwigPyObject_as_number = {
(binaryfunc)0, /*nb_add*/
(binaryfunc)0, /*nb_subtract*/
(binaryfunc)0, /*nb_multiply*/
/* nb_divide removed in Python 3 */
#if PY_VERSION_HEX < 0x03000000
(binaryfunc)0, /*nb_divide*/
#endif
(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*/
#if PY_VERSION_HEX < 0x03000000
0, /*nb_coerce*/
#endif
(unaryfunc)SwigPyObject_long, /*nb_int*/
#if PY_VERSION_HEX < 0x03000000
(unaryfunc)SwigPyObject_long, /*nb_long*/
#else
0, /*nb_reserved*/
#endif
(unaryfunc)0, /*nb_float*/
#if PY_VERSION_HEX < 0x03000000
(unaryfunc)SwigPyObject_oct, /*nb_oct*/
(unaryfunc)SwigPyObject_hex, /*nb_hex*/
#endif
#if PY_VERSION_HEX >= 0x03050000 /* 3.5 */
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_matrix_multiply */
#elif PY_VERSION_HEX >= 0x03000000 /* 3.0 */
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index, nb_inplace_divide removed */
#elif 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 swigpyobject_type;
static int type_init = 0;
if (!type_init) {
const PyTypeObject tmp = {
/* PyObject header changed in Python 3 */
#if PY_VERSION_HEX >= 0x03000000
PyVarObject_HEAD_INIT(NULL, 0)
#else
PyObject_HEAD_INIT(NULL)
0, /* ob_size */
#endif
(char *)"SwigPyObject", /* tp_name */
sizeof(SwigPyObject), /* tp_basicsize */
0, /* tp_itemsize */
(destructor)SwigPyObject_dealloc, /* tp_dealloc */
0, /* tp_print */
#if PY_VERSION_HEX < 0x02020000
(getattrfunc)SwigPyObject_getattr, /* tp_getattr */
#else
(getattrfunc)0, /* tp_getattr */
#endif
(setattrfunc)0, /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
0, /* tp_reserved in 3.0.1, tp_compare in 3.0.0 but not used */
#else
(cmpfunc)SwigPyObject_compare, /* tp_compare */
#endif
(reprfunc)SwigPyObject_repr, /* tp_repr */
&SwigPyObject_as_number, /* tp_as_number */
0, /* tp_as_sequence */
0, /* tp_as_mapping */
(hashfunc)0, /* tp_hash */
(ternaryfunc)0, /* tp_call */
0, /* 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 */
(richcmpfunc)SwigPyObject_richcompare,/* 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
#if PY_VERSION_HEX >= 0x02060000
0, /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
0, /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
0, /* tp_allocs */
0, /* tp_frees */
0, /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
0, /* tp_prev */
#endif
0 /* tp_next */
#endif
};
swigpyobject_type = tmp;
type_init = 1;
#if PY_VERSION_HEX < 0x02020000
swigpyobject_type.ob_type = &PyType_Type;
#else
if (PyType_Ready(&swigpyobject_type) < 0)
return NULL;
#endif
}
return &swigpyobject_type;
}
SWIGRUNTIME PyObject *
SwigPyObject_New(void *ptr, swig_type_info *ty, int own)
{
SwigPyObject *sobj = PyObject_NEW(SwigPyObject, SwigPyObject_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;
} SwigPyPacked;
SWIGRUNTIME int
SwigPyPacked_print(SwigPyPacked *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 *
SwigPyPacked_repr(SwigPyPacked *v)
{
char result[SWIG_BUFFER_SIZE];
if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
return SWIG_Python_str_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
} else {
return SWIG_Python_str_FromFormat("<Swig Packed %s>", v->ty->name);
}
}
SWIGRUNTIME PyObject *
SwigPyPacked_str(SwigPyPacked *v)
{
char result[SWIG_BUFFER_SIZE];
if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
return SWIG_Python_str_FromFormat("%s%s", result, v->ty->name);
} else {
return SWIG_Python_str_FromChar(v->ty->name);
}
}
SWIGRUNTIME int
SwigPyPacked_compare(SwigPyPacked *v, SwigPyPacked *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* SwigPyPacked_TypeOnce(void);
SWIGRUNTIME PyTypeObject*
SwigPyPacked_type(void) {
static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyPacked_TypeOnce();
return type;
}
SWIGRUNTIMEINLINE int
SwigPyPacked_Check(PyObject *op) {
return ((op)->ob_type == SwigPyPacked_TypeOnce())
|| (strcmp((op)->ob_type->tp_name,"SwigPyPacked") == 0);
}
SWIGRUNTIME void
SwigPyPacked_dealloc(PyObject *v)
{
if (SwigPyPacked_Check(v)) {
SwigPyPacked *sobj = (SwigPyPacked *) v;
free(sobj->pack);
}
PyObject_DEL(v);
}
SWIGRUNTIME PyTypeObject*
SwigPyPacked_TypeOnce(void) {
static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
static PyTypeObject swigpypacked_type;
static int type_init = 0;
if (!type_init) {
const PyTypeObject tmp = {
/* PyObject header changed in Python 3 */
#if PY_VERSION_HEX>=0x03000000
PyVarObject_HEAD_INIT(NULL, 0)
#else
PyObject_HEAD_INIT(NULL)
0, /* ob_size */
#endif
(char *)"SwigPyPacked", /* tp_name */
sizeof(SwigPyPacked), /* tp_basicsize */
0, /* tp_itemsize */
(destructor)SwigPyPacked_dealloc, /* tp_dealloc */
(printfunc)SwigPyPacked_print, /* tp_print */
(getattrfunc)0, /* tp_getattr */
(setattrfunc)0, /* tp_setattr */
#if PY_VERSION_HEX>=0x03000000
0, /* tp_reserved in 3.0.1 */
#else
(cmpfunc)SwigPyPacked_compare, /* tp_compare */
#endif
(reprfunc)SwigPyPacked_repr, /* tp_repr */
0, /* tp_as_number */
0, /* tp_as_sequence */
0, /* tp_as_mapping */
(hashfunc)0, /* tp_hash */
(ternaryfunc)0, /* tp_call */
(reprfunc)SwigPyPacked_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
#if PY_VERSION_HEX >= 0x02060000
0, /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
0, /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
0, /* tp_allocs */
0, /* tp_frees */
0, /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
0, /* tp_prev */
#endif
0 /* tp_next */
#endif
};
swigpypacked_type = tmp;
type_init = 1;
#if PY_VERSION_HEX < 0x02020000
swigpypacked_type.ob_type = &PyType_Type;
#else
if (PyType_Ready(&swigpypacked_type) < 0)
return NULL;
#endif
}
return &swigpypacked_type;
}
SWIGRUNTIME PyObject *
SwigPyPacked_New(void *ptr, size_t size, swig_type_info *ty)
{
SwigPyPacked *sobj = PyObject_NEW(SwigPyPacked, SwigPyPacked_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 *
SwigPyPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
{
if (SwigPyPacked_Check(obj)) {
SwigPyPacked *sobj = (SwigPyPacked *)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 SWIG_Python_str_FromChar("this");
}
static PyObject *swig_this = NULL;
SWIGRUNTIME PyObject *
SWIG_This(void)
{
if (swig_this == NULL)
swig_this = _SWIG_This();
return swig_this;
}
/* #define SWIG_PYTHON_SLOW_GETSET_THIS */
/* TODO: I don't know how to implement the fast getset in Python 3 right now */
#if PY_VERSION_HEX>=0x03000000
#define SWIG_PYTHON_SLOW_GETSET_THIS
#endif
SWIGRUNTIME SwigPyObject *
SWIG_Python_GetSwigThis(PyObject *pyobj)
{
PyObject *obj;
if (SwigPyObject_Check(pyobj))
return (SwigPyObject *) pyobj;
#ifdef SWIGPYTHON_BUILTIN
(void)obj;
# ifdef PyWeakref_CheckProxy
if (PyWeakref_CheckProxy(pyobj)) {
pyobj = PyWeakref_GET_OBJECT(pyobj);
if (pyobj && SwigPyObject_Check(pyobj))
return (SwigPyObject*) pyobj;
}
# endif
return NULL;
#else
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 && !SwigPyObject_Check(obj)) {
/* a PyObject is called 'this', try to get the 'real this'
SwigPyObject from it */
return SWIG_Python_GetSwigThis(obj);
}
return (SwigPyObject *)obj;
#endif
}
/* Acquire a pointer value */
SWIGRUNTIME int
SWIG_Python_AcquirePtr(PyObject *obj, int own) {
if (own == SWIG_POINTER_OWN) {
SwigPyObject *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) {
int res;
SwigPyObject *sobj;
int implicit_conv = (flags & SWIG_POINTER_IMPLICIT_CONV) != 0;
if (!obj)
return SWIG_ERROR;
if (obj == Py_None && !implicit_conv) {
if (ptr)
*ptr = 0;
return SWIG_OK;
}
res = SWIG_ERROR;
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 = (SwigPyObject *)sobj->next;
} else {
if (ptr) {
int newmemory = 0;
*ptr = SWIG_TypeCast(tc,vptr,&newmemory);
if (newmemory == SWIG_CAST_NEW_MEMORY) {
assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
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;
}
res = SWIG_OK;
} else {
if (implicit_conv) {
SwigPyClientData *data = ty ? (SwigPyClientData *) 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) {
SwigPyObject *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);
}
}
}
}
if (!SWIG_IsOK(res) && obj == Py_None) {
if (ptr)
*ptr = 0;
if (PyErr_Occurred())
PyErr_Clear();
res = SWIG_OK;
}
}
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 = (((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 = SwigPyPacked_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, without calling __init__, and set the
'this' attribute.
*/
SWIGRUNTIME PyObject*
SWIG_Python_NewShadowInstance(SwigPyClientData *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 {
#if PY_VERSION_HEX >= 0x03000000
inst = ((PyTypeObject*) data->newargs)->tp_new((PyTypeObject*) data->newargs, Py_None, Py_None);
if (inst) {
PyObject_SetAttr(inst, SWIG_This(), swig_this);
Py_TYPE(inst)->tp_flags &= ~Py_TPFLAGS_VALID_VERSION_TAG;
}
#else
PyObject *dict = PyDict_New();
if (dict) {
PyDict_SetItem(dict, SWIG_This(), swig_this);
inst = PyInstance_NewRaw(data->newargs, dict);
Py_DECREF(dict);
}
#endif
}
return inst;
#else
#if (PY_VERSION_HEX >= 0x02010000)
PyObject *inst = 0;
PyObject *dict = PyDict_New();
if (dict) {
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, "swiginit", 2, 2, obj)) {
return NULL;
} else {
SwigPyObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
if (sthis) {
SwigPyObject_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(PyObject *self, void *ptr, swig_type_info *type, int flags) {
SwigPyClientData *clientdata;
PyObject * robj;
int own;
if (!ptr)
return SWIG_Py_Void();
clientdata = type ? (SwigPyClientData *)(type->clientdata) : 0;
own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
if (clientdata && clientdata->pytype) {
SwigPyObject *newobj;
if (flags & SWIG_BUILTIN_TP_INIT) {
newobj = (SwigPyObject*) self;
if (newobj->ptr) {
PyObject *next_self = clientdata->pytype->tp_alloc(clientdata->pytype, 0);
while (newobj->next)
newobj = (SwigPyObject *) newobj->next;
newobj->next = next_self;
newobj = (SwigPyObject *)next_self;
#ifdef SWIGPYTHON_BUILTIN
newobj->dict = 0;
#endif
}
} else {
newobj = PyObject_New(SwigPyObject, clientdata->pytype);
#ifdef SWIGPYTHON_BUILTIN
newobj->dict = 0;
#endif
}
if (newobj) {
newobj->ptr = ptr;
newobj->ty = type;
newobj->own = own;
newobj->next = 0;
return (PyObject*) newobj;
}
return SWIG_Py_Void();
}
assert(!(flags & SWIG_BUILTIN_TP_INIT));
robj = SwigPyObject_New(ptr, type, own);
if (robj && clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
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 ? SwigPyPacked_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 *SWIGUNUSEDPARM(clientdata)) {
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
# ifdef SWIGPY_USE_CAPSULE
type_pointer = PyCapsule_Import(SWIGPY_CAPSULE_NAME, 0);
# else
type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
(char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
# endif
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
#ifdef SWIGPY_USE_CAPSULE
SWIG_Python_DestroyModule(PyObject *obj)
#else
SWIG_Python_DestroyModule(void *vptr)
#endif
{
#ifdef SWIGPY_USE_CAPSULE
swig_module_info *swig_module = (swig_module_info *) PyCapsule_GetPointer(obj, SWIGPY_CAPSULE_NAME);
#else
swig_module_info *swig_module = (swig_module_info *) vptr;
#endif
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) {
SwigPyClientData *data = (SwigPyClientData *) ty->clientdata;
if (data) SwigPyClientData_Del(data);
}
}
Py_DECREF(SWIG_This());
swig_this = NULL;
}
SWIGRUNTIME void
SWIG_Python_SetModule(swig_module_info *swig_module) {
#if PY_VERSION_HEX >= 0x03000000
/* Add a dummy module object into sys.modules */
PyObject *module = PyImport_AddModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION);
#else
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);
#endif
#ifdef SWIGPY_USE_CAPSULE
PyObject *pointer = PyCapsule_New((void *) swig_module, SWIGPY_CAPSULE_NAME, SWIG_Python_DestroyModule);
if (pointer && module) {
PyModule_AddObject(module, (char*)"type_pointer_capsule" SWIG_TYPE_TABLE_NAME, pointer);
} else {
Py_XDECREF(pointer);
}
#else
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);
}
#endif
}
/* 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 = SWIG_Python_str_FromChar(type);
PyObject *obj = PyDict_GetItem(cache, key);
swig_type_info *descriptor;
if (obj) {
#ifdef SWIGPY_USE_CAPSULE
descriptor = (swig_type_info *) PyCapsule_GetPointer(obj, NULL);
#else
descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
#endif
} else {
swig_module_info *swig_module = SWIG_GetModule(0);
descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
if (descriptor) {
#ifdef SWIGPY_USE_CAPSULE
obj = PyCapsule_New((void*) descriptor, NULL, NULL);
#else
obj = PyCObject_FromVoidPtr(descriptor, NULL);
#endif
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) {
char *tmp;
PyObject *old_str = PyObject_Str(value);
Py_XINCREF(type);
PyErr_Clear();
if (infront) {
PyErr_Format(type, "%s %s", mesg, tmp = SWIG_Python_str_AsChar(old_str));
} else {
PyErr_Format(type, "%s %s", tmp = SWIG_Python_str_AsChar(old_str), mesg);
}
SWIG_Python_str_DelForPy3(tmp);
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 *
SwigPyObject_GetDesc(PyObject *self)
{
SwigPyObject *v = (SwigPyObject *)self;
swig_type_info *ty = v ? v->ty : 0;
return ty ? ty->str : "";
}
SWIGRUNTIME void
SWIG_Python_TypeError(const char *type, PyObject *obj)
{
if (type) {
#if defined(SWIG_COBJECT_TYPES)
if (obj && SwigPyObject_Check(obj)) {
const char *otype = (const char *) SwigPyObject_GetDesc(obj);
if (otype) {
PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'SwigPyObject(%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 ? SWIG_Python_str_AsChar(str) : 0;
if (cstr) {
PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
type, otype, cstr);
SWIG_Python_str_DelForPy3(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 SWIGUNUSEDPARM(argnum), int flags) {
void *result;
if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
PyErr_Clear();
#if SWIG_POINTER_EXCEPTION
if (flags) {
SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
SWIG_Python_ArgFail(argnum);
}
#endif
}
return result;
}
#ifdef SWIGPYTHON_BUILTIN
SWIGRUNTIME int
SWIG_Python_NonDynamicSetAttr(PyObject *obj, PyObject *name, PyObject *value) {
PyTypeObject *tp = obj->ob_type;
PyObject *descr;
PyObject *encoded_name;
descrsetfunc f;
int res = -1;
# ifdef Py_USING_UNICODE
if (PyString_Check(name)) {
name = PyUnicode_Decode(PyString_AsString(name), PyString_Size(name), NULL, NULL);
if (!name)
return -1;
} else if (!PyUnicode_Check(name))
# else
if (!PyString_Check(name))
# endif
{
PyErr_Format(PyExc_TypeError, "attribute name must be string, not '%.200s'", name->ob_type->tp_name);
return -1;
} else {
Py_INCREF(name);
}
if (!tp->tp_dict) {
if (PyType_Ready(tp) < 0)
goto done;
}
descr = _PyType_Lookup(tp, name);
f = NULL;
if (descr != NULL)
f = descr->ob_type->tp_descr_set;
if (!f) {
if (PyString_Check(name)) {
encoded_name = name;
Py_INCREF(name);
} else {
encoded_name = PyUnicode_AsUTF8String(name);
}
PyErr_Format(PyExc_AttributeError, "'%.100s' object has no attribute '%.200s'", tp->tp_name, PyString_AsString(encoded_name));
Py_DECREF(encoded_name);
} else {
res = f(descr, obj, value);
}
done:
Py_DECREF(name);
return res;
}
#endif
#ifdef __cplusplus
}
#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
#define SWIG_exception(code, msg) do { SWIG_Error(code, msg); SWIG_fail;; } while(0)
/* -------- TYPES TABLE (BEGIN) -------- */
#define SWIGTYPE_p_CmDevice swig_types[0]
#define SWIGTYPE_p_InputParamMap swig_types[1]
#define SWIGTYPE_p_KCFTracker swig_types[2]
#define SWIGTYPE_p_Tracker swig_types[3]
#define SWIGTYPE_p__mat__np_array_constructor swig_types[4]
#define SWIGTYPE_p_allocator_type swig_types[5]
#define SWIGTYPE_p_channel_type swig_types[6]
#define SWIGTYPE_p_char swig_types[7]
#define SWIGTYPE_p_cv__DataTypeT_bool_t swig_types[8]
#define SWIGTYPE_p_cv__DataTypeT_char_t swig_types[9]
#define SWIGTYPE_p_cv__DataTypeT_cv__VecT_double_2_t_t swig_types[10]
#define SWIGTYPE_p_cv__DataTypeT_cv__VecT_double_3_t_t swig_types[11]
#define SWIGTYPE_p_cv__DataTypeT_cv__VecT_double_4_t_t swig_types[12]
#define SWIGTYPE_p_cv__DataTypeT_cv__VecT_double_6_t_t swig_types[13]
#define SWIGTYPE_p_cv__DataTypeT_cv__VecT_float_2_t_t swig_types[14]
#define SWIGTYPE_p_cv__DataTypeT_cv__VecT_float_3_t_t swig_types[15]
#define SWIGTYPE_p_cv__DataTypeT_cv__VecT_float_4_t_t swig_types[16]
#define SWIGTYPE_p_cv__DataTypeT_cv__VecT_float_6_t_t swig_types[17]
#define SWIGTYPE_p_cv__DataTypeT_cv__VecT_int_2_t_t swig_types[18]
#define SWIGTYPE_p_cv__DataTypeT_cv__VecT_int_3_t_t swig_types[19]
#define SWIGTYPE_p_cv__DataTypeT_cv__VecT_int_4_t_t swig_types[20]
#define SWIGTYPE_p_cv__DataTypeT_cv__VecT_int_6_t_t swig_types[21]
#define SWIGTYPE_p_cv__DataTypeT_cv__VecT_int_8_t_t swig_types[22]
#define SWIGTYPE_p_cv__DataTypeT_cv__VecT_short_2_t_t swig_types[23]
#define SWIGTYPE_p_cv__DataTypeT_cv__VecT_short_3_t_t swig_types[24]
#define SWIGTYPE_p_cv__DataTypeT_cv__VecT_short_4_t_t swig_types[25]
#define SWIGTYPE_p_cv__DataTypeT_cv__VecT_uint8_t_2_t_t swig_types[26]
#define SWIGTYPE_p_cv__DataTypeT_cv__VecT_uint8_t_3_t_t swig_types[27]
#define SWIGTYPE_p_cv__DataTypeT_cv__VecT_uint8_t_4_t_t swig_types[28]
#define SWIGTYPE_p_cv__DataTypeT_cv__VecT_ushort_2_t_t swig_types[29]
#define SWIGTYPE_p_cv__DataTypeT_cv__VecT_ushort_3_t_t swig_types[30]
#define SWIGTYPE_p_cv__DataTypeT_cv__VecT_ushort_4_t_t swig_types[31]
#define SWIGTYPE_p_cv__DataTypeT_double_t swig_types[32]
#define SWIGTYPE_p_cv__DataTypeT_float_t swig_types[33]
#define SWIGTYPE_p_cv__DataTypeT_int_t swig_types[34]
#define SWIGTYPE_p_cv__DataTypeT_schar_t swig_types[35]
#define SWIGTYPE_p_cv__DataTypeT_short_t swig_types[36]
#define SWIGTYPE_p_cv__DataTypeT_uchar_t swig_types[37]
#define SWIGTYPE_p_cv__DataTypeT_ushort_t swig_types[38]
#define SWIGTYPE_p_cv__Mat swig_types[39]
#define SWIGTYPE_p_cv__Mat_T_cv__VecT_double_2_t_t swig_types[40]
#define SWIGTYPE_p_cv__Mat_T_cv__VecT_double_3_t_t swig_types[41]
#define SWIGTYPE_p_cv__Mat_T_cv__VecT_double_4_t_t swig_types[42]
#define SWIGTYPE_p_cv__Mat_T_cv__VecT_float_2_t_t swig_types[43]
#define SWIGTYPE_p_cv__Mat_T_cv__VecT_float_3_t_t swig_types[44]
#define SWIGTYPE_p_cv__Mat_T_cv__VecT_float_4_t_t swig_types[45]
#define SWIGTYPE_p_cv__Mat_T_cv__VecT_int_2_t_t swig_types[46]
#define SWIGTYPE_p_cv__Mat_T_cv__VecT_int_3_t_t swig_types[47]
#define SWIGTYPE_p_cv__Mat_T_cv__VecT_int_4_t_t swig_types[48]
#define SWIGTYPE_p_cv__Mat_T_cv__VecT_short_2_t_t swig_types[49]
#define SWIGTYPE_p_cv__Mat_T_cv__VecT_short_3_t_t swig_types[50]
#define SWIGTYPE_p_cv__Mat_T_cv__VecT_short_4_t_t swig_types[51]
#define SWIGTYPE_p_cv__Mat_T_cv__VecT_uint8_t_2_t_t swig_types[52]
#define SWIGTYPE_p_cv__Mat_T_cv__VecT_uint8_t_3_t_t swig_types[53]
#define SWIGTYPE_p_cv__Mat_T_cv__VecT_uint8_t_4_t_t swig_types[54]
#define SWIGTYPE_p_cv__Mat_T_cv__VecT_ushort_2_t_t swig_types[55]
#define SWIGTYPE_p_cv__Mat_T_cv__VecT_ushort_3_t_t swig_types[56]
#define SWIGTYPE_p_cv__Mat_T_cv__VecT_ushort_4_t_t swig_types[57]
#define SWIGTYPE_p_cv__Mat_T_double_t swig_types[58]
#define SWIGTYPE_p_cv__Mat_T_float_t swig_types[59]
#define SWIGTYPE_p_cv__Mat_T_int_t swig_types[60]
#define SWIGTYPE_p_cv__Mat_T_short_t swig_types[61]
#define SWIGTYPE_p_cv__Mat_T_uchar_t swig_types[62]
#define SWIGTYPE_p_cv__Mat_T_ushort_t swig_types[63]
#define SWIGTYPE_p_cv__MatxT_double_1_2_t swig_types[64]
#define SWIGTYPE_p_cv__MatxT_double_1_3_t swig_types[65]
#define SWIGTYPE_p_cv__MatxT_double_1_4_t swig_types[66]
#define SWIGTYPE_p_cv__MatxT_double_1_6_t swig_types[67]
#define SWIGTYPE_p_cv__MatxT_double_2_1_t swig_types[68]
#define SWIGTYPE_p_cv__MatxT_double_2_2_t swig_types[69]
#define SWIGTYPE_p_cv__MatxT_double_2_3_t swig_types[70]
#define SWIGTYPE_p_cv__MatxT_double_3_1_t swig_types[71]
#define SWIGTYPE_p_cv__MatxT_double_3_2_t swig_types[72]
#define SWIGTYPE_p_cv__MatxT_double_3_3_t swig_types[73]
#define SWIGTYPE_p_cv__MatxT_double_3_4_t swig_types[74]
#define SWIGTYPE_p_cv__MatxT_double_4_1_t swig_types[75]
#define SWIGTYPE_p_cv__MatxT_double_4_3_t swig_types[76]
#define SWIGTYPE_p_cv__MatxT_double_4_4_t swig_types[77]
#define SWIGTYPE_p_cv__MatxT_double_6_1_t swig_types[78]
#define SWIGTYPE_p_cv__MatxT_double_6_6_t swig_types[79]
#define SWIGTYPE_p_cv__MatxT_float_1_2_t swig_types[80]
#define SWIGTYPE_p_cv__MatxT_float_1_3_t swig_types[81]
#define SWIGTYPE_p_cv__MatxT_float_1_4_t swig_types[82]
#define SWIGTYPE_p_cv__MatxT_float_1_6_t swig_types[83]
#define SWIGTYPE_p_cv__MatxT_float_2_1_t swig_types[84]
#define SWIGTYPE_p_cv__MatxT_float_2_2_t swig_types[85]
#define SWIGTYPE_p_cv__MatxT_float_2_3_t swig_types[86]
#define SWIGTYPE_p_cv__MatxT_float_3_1_t swig_types[87]
#define SWIGTYPE_p_cv__MatxT_float_3_2_t swig_types[88]
#define SWIGTYPE_p_cv__MatxT_float_3_3_t swig_types[89]
#define SWIGTYPE_p_cv__MatxT_float_3_4_t swig_types[90]
#define SWIGTYPE_p_cv__MatxT_float_4_1_t swig_types[91]
#define SWIGTYPE_p_cv__MatxT_float_4_3_t swig_types[92]
#define SWIGTYPE_p_cv__MatxT_float_4_4_t swig_types[93]
#define SWIGTYPE_p_cv__MatxT_float_6_1_t swig_types[94]
#define SWIGTYPE_p_cv__MatxT_float_6_6_t swig_types[95]
#define SWIGTYPE_p_cv__MatxT_int_1_2_t swig_types[96]
#define SWIGTYPE_p_cv__MatxT_int_1_3_t swig_types[97]
#define SWIGTYPE_p_cv__MatxT_int_1_4_t swig_types[98]
#define SWIGTYPE_p_cv__MatxT_int_1_6_t swig_types[99]
#define SWIGTYPE_p_cv__MatxT_int_1_8_t swig_types[100]
#define SWIGTYPE_p_cv__MatxT_int_2_1_t swig_types[101]
#define SWIGTYPE_p_cv__MatxT_int_3_1_t swig_types[102]
#define SWIGTYPE_p_cv__MatxT_int_4_1_t swig_types[103]
#define SWIGTYPE_p_cv__MatxT_int_6_1_t swig_types[104]
#define SWIGTYPE_p_cv__MatxT_int_8_1_t swig_types[105]
#define SWIGTYPE_p_cv__MatxT_short_1_2_t swig_types[106]
#define SWIGTYPE_p_cv__MatxT_short_1_3_t swig_types[107]
#define SWIGTYPE_p_cv__MatxT_short_1_4_t swig_types[108]
#define SWIGTYPE_p_cv__MatxT_short_2_1_t swig_types[109]
#define SWIGTYPE_p_cv__MatxT_short_3_1_t swig_types[110]
#define SWIGTYPE_p_cv__MatxT_short_4_1_t swig_types[111]
#define SWIGTYPE_p_cv__MatxT_unsigned_char_1_2_t swig_types[112]
#define SWIGTYPE_p_cv__MatxT_unsigned_char_1_3_t swig_types[113]
#define SWIGTYPE_p_cv__MatxT_unsigned_char_1_4_t swig_types[114]
#define SWIGTYPE_p_cv__MatxT_unsigned_char_2_1_t swig_types[115]
#define SWIGTYPE_p_cv__MatxT_unsigned_char_3_1_t swig_types[116]
#define SWIGTYPE_p_cv__MatxT_unsigned_char_4_1_t swig_types[117]
#define SWIGTYPE_p_cv__MatxT_ushort_1_2_t swig_types[118]
#define SWIGTYPE_p_cv__MatxT_ushort_1_3_t swig_types[119]
#define SWIGTYPE_p_cv__MatxT_ushort_1_4_t swig_types[120]
#define SWIGTYPE_p_cv__MatxT_ushort_2_1_t swig_types[121]
#define SWIGTYPE_p_cv__MatxT_ushort_3_1_t swig_types[122]
#define SWIGTYPE_p_cv__MatxT_ushort_4_1_t swig_types[123]
#define SWIGTYPE_p_cv__Matx_AddOp swig_types[124]
#define SWIGTYPE_p_cv__Matx_DivOp swig_types[125]
#define SWIGTYPE_p_cv__Matx_MatMulOp swig_types[126]
#define SWIGTYPE_p_cv__Matx_MulOp swig_types[127]
#define SWIGTYPE_p_cv__Matx_ScaleOp swig_types[128]
#define SWIGTYPE_p_cv__Matx_SubOp swig_types[129]
#define SWIGTYPE_p_cv__Matx_TOp swig_types[130]
#define SWIGTYPE_p_cv__Point_T_double_t swig_types[131]
#define SWIGTYPE_p_cv__Point_T_float_t swig_types[132]
#define SWIGTYPE_p_cv__Point_T_int_t swig_types[133]
#define SWIGTYPE_p_cv__Range swig_types[134]
#define SWIGTYPE_p_cv__Rect_T_double_t swig_types[135]
#define SWIGTYPE_p_cv__Rect_T_float_t swig_types[136]
#define SWIGTYPE_p_cv__Rect_T_int_t swig_types[137]
#define SWIGTYPE_p_cv__Scalar_T_double_t swig_types[138]
#define SWIGTYPE_p_cv__Size_T_double_t swig_types[139]
#define SWIGTYPE_p_cv__Size_T_float_t swig_types[140]
#define SWIGTYPE_p_cv__Size_T_int_t swig_types[141]
#define SWIGTYPE_p_cv__VecT_double_2_t swig_types[142]
#define SWIGTYPE_p_cv__VecT_double_3_t swig_types[143]
#define SWIGTYPE_p_cv__VecT_double_4_t swig_types[144]
#define SWIGTYPE_p_cv__VecT_double_6_t swig_types[145]
#define SWIGTYPE_p_cv__VecT_float_2_t swig_types[146]
#define SWIGTYPE_p_cv__VecT_float_3_t swig_types[147]
#define SWIGTYPE_p_cv__VecT_float_4_t swig_types[148]
#define SWIGTYPE_p_cv__VecT_float_6_t swig_types[149]
#define SWIGTYPE_p_cv__VecT_int_2_t swig_types[150]
#define SWIGTYPE_p_cv__VecT_int_3_t swig_types[151]
#define SWIGTYPE_p_cv__VecT_int_4_t swig_types[152]
#define SWIGTYPE_p_cv__VecT_int_6_t swig_types[153]
#define SWIGTYPE_p_cv__VecT_int_8_t swig_types[154]
#define SWIGTYPE_p_cv__VecT_short_2_t swig_types[155]
#define SWIGTYPE_p_cv__VecT_short_3_t swig_types[156]
#define SWIGTYPE_p_cv__VecT_short_4_t swig_types[157]
#define SWIGTYPE_p_cv__VecT_unsigned_char_2_t swig_types[158]
#define SWIGTYPE_p_cv__VecT_unsigned_char_3_t swig_types[159]
#define SWIGTYPE_p_cv__VecT_unsigned_char_4_t swig_types[160]
#define SWIGTYPE_p_cv__VecT_ushort_2_t swig_types[161]
#define SWIGTYPE_p_cv__VecT_ushort_3_t swig_types[162]
#define SWIGTYPE_p_cv__VecT_ushort_4_t swig_types[163]
#define SWIGTYPE_p_cv___SizeOfT_double_t swig_types[164]
#define SWIGTYPE_p_cv___SizeOfT_float_t swig_types[165]
#define SWIGTYPE_p_cv___SizeOfT_int_t swig_types[166]
#define SWIGTYPE_p_cv___SizeOfT_short_t swig_types[167]
#define SWIGTYPE_p_cv___SizeOfT_unsigned_char_t swig_types[168]
#define SWIGTYPE_p_cv___SizeOfT_ushort_t swig_types[169]
#define SWIGTYPE_p_diag_type swig_types[170]
#define SWIGTYPE_p_difference_type swig_types[171]
#define SWIGTYPE_p_double swig_types[172]
#define SWIGTYPE_p_float swig_types[173]
#define SWIGTYPE_p_int swig_types[174]
#define SWIGTYPE_p_long_long swig_types[175]
#define SWIGTYPE_p_mat_type swig_types[176]
#define SWIGTYPE_p_p_PyObject swig_types[177]
#define SWIGTYPE_p_sPerfProfileParam swig_types[178]
#define SWIGTYPE_p_short swig_types[179]
#define SWIGTYPE_p_signed_char swig_types[180]
#define SWIGTYPE_p_size_t swig_types[181]
#define SWIGTYPE_p_size_type swig_types[182]
#define SWIGTYPE_p_std__allocatorT_double_t swig_types[183]
#define SWIGTYPE_p_std__allocatorT_float_t swig_types[184]
#define SWIGTYPE_p_std__allocatorT_int_t swig_types[185]
#define SWIGTYPE_p_std__allocatorT_short_t swig_types[186]
#define SWIGTYPE_p_std__allocatorT_unsigned_char_t swig_types[187]
#define SWIGTYPE_p_std__allocatorT_ushort_t swig_types[188]
#define SWIGTYPE_p_std__invalid_argument swig_types[189]
#define SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t swig_types[190]
#define SWIGTYPE_p_std__vectorT_float_std__allocatorT_float_t_t swig_types[191]
#define SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t swig_types[192]
#define SWIGTYPE_p_std__vectorT_short_std__allocatorT_short_t_t swig_types[193]
#define SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t swig_types[194]
#define SWIGTYPE_p_std__vectorT_ushort_std__allocatorT_ushort_t_t swig_types[195]
#define SWIGTYPE_p_swig__SwigPyIterator swig_types[196]
#define SWIGTYPE_p_uchar swig_types[197]
#define SWIGTYPE_p_unsigned_char swig_types[198]
#define SWIGTYPE_p_unsigned_int swig_types[199]
#define SWIGTYPE_p_unsigned_long_long swig_types[200]
#define SWIGTYPE_p_unsigned_short swig_types[201]
#define SWIGTYPE_p_ushort swig_types[202]
#define SWIGTYPE_p_value_type swig_types[203]
#define SWIGTYPE_p_vec_type swig_types[204]
#define SWIGTYPE_p_void swig_types[205]
#define SWIGTYPE_p_work_type swig_types[206]
static swig_type_info *swig_types[208];
static swig_module_info swig_module = {swig_types, 207, 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):= _kcftracker.so
------------------------------------------------*/
#if PY_VERSION_HEX >= 0x03000000
# define SWIG_init PyInit__kcftracker
#else
# define SWIG_init init_kcftracker
#endif
#define SWIG_name "_kcftracker"
#define SWIGVERSION 0x030008
#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 SwigPtr_PyObject {
protected:
PyObject *_obj;
public:
SwigPtr_PyObject() :_obj(0)
{
}
SwigPtr_PyObject(const SwigPtr_PyObject& item) : _obj(item._obj)
{
SWIG_PYTHON_THREAD_BEGIN_BLOCK;
Py_XINCREF(_obj);
SWIG_PYTHON_THREAD_END_BLOCK;
}
SwigPtr_PyObject(PyObject *obj, bool initial_ref = true) :_obj(obj)
{
if (initial_ref) {
SWIG_PYTHON_THREAD_BEGIN_BLOCK;
Py_XINCREF(_obj);
SWIG_PYTHON_THREAD_END_BLOCK;
}
}
SwigPtr_PyObject & operator=(const SwigPtr_PyObject& item)
{
SWIG_PYTHON_THREAD_BEGIN_BLOCK;
Py_XINCREF(item._obj);
Py_XDECREF(_obj);
_obj = item._obj;
SWIG_PYTHON_THREAD_END_BLOCK;
return *this;
}
~SwigPtr_PyObject()
{
SWIG_PYTHON_THREAD_BEGIN_BLOCK;
Py_XDECREF(_obj);
SWIG_PYTHON_THREAD_END_BLOCK;
}
operator PyObject *() const
{
return _obj;
}
PyObject *operator->() const
{
return _obj;
}
};
}
namespace swig {
struct SwigVar_PyObject : SwigPtr_PyObject {
SwigVar_PyObject(PyObject* obj = 0) : SwigPtr_PyObject(obj, false) { }
SwigVar_PyObject & operator = (PyObject* obj)
{
Py_XDECREF(_obj);
_obj = obj;
return *this;
}
};
}
namespace cv
{
template <typename T>
struct _SizeOf
{
enum {value = sizeof(T)};
};
}
#include <opencv2/core/core.hpp>
SWIGINTERNINLINE PyObject*
SWIG_From_int (int value)
{
return PyInt_FromLong((long) value);
}
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_InternalNewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
} else {
#if PY_VERSION_HEX >= 0x03000000
#if PY_VERSION_HEX >= 0x03010000
return PyUnicode_DecodeUTF8(carray, static_cast< Py_ssize_t >(size), "surrogateescape");
#else
return PyUnicode_FromStringAndSize(carray, static_cast< Py_ssize_t >(size));
#endif
#else
return PyString_FromStringAndSize(carray, static_cast< Py_ssize_t >(size));
#endif
}
} else {
return SWIG_Py_Void();
}
}
SWIGINTERNINLINE PyObject *
SWIG_FromCharPtr(const char *cptr)
{
return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
}
SWIGINTERNINLINE PyObject *
SWIG_From_char (char c)
{
return SWIG_FromCharPtrAndSize(&c,1);
}
#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_double (PyObject *obj, double *val)
{
int res = SWIG_TypeError;
if (PyFloat_Check(obj)) {
if (val) *val = PyFloat_AsDouble(obj);
return SWIG_OK;
#if PY_VERSION_HEX < 0x03000000
} else if (PyInt_Check(obj)) {
if (val) *val = PyInt_AsLong(obj);
return SWIG_OK;
#endif
} 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_long (PyObject *obj, long* val)
{
#if PY_VERSION_HEX < 0x03000000
if (PyInt_Check(obj)) {
if (val) *val = PyInt_AsLong(obj);
return SWIG_OK;
} else
#endif
if (PyLong_Check(obj)) {
long v = PyLong_AsLong(obj);
if (!PyErr_Occurred()) {
if (val) *val = v;
return SWIG_OK;
} else {
PyErr_Clear();
return SWIG_OverflowError;
}
}
#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;
}
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;
}
SWIGINTERNINLINE PyObject*
SWIG_From_bool (bool value)
{
return PyBool_FromLong(value ? 1 : 0);
}
#include <stdint.h> // Use the C99 official header
#include <string>
#include <iostream>
#if PY_VERSION_HEX >= 0x03020000
# define SWIGPY_SLICE_ARG(obj) ((PyObject*) (obj))
#else
# define SWIGPY_SLICE_ARG(obj) ((PySliceObject*) (obj))
#endif
#include <stdexcept>
#if defined(__GNUC__)
# if __GNUC__ == 2 && __GNUC_MINOR <= 96
# define SWIG_STD_NOMODERN_STL
# endif
#endif
#include <stddef.h>
namespace swig {
struct stop_iteration {
};
struct SwigPyIterator {
private:
SwigPtr_PyObject _seq;
protected:
SwigPyIterator(PyObject *seq) : _seq(seq)
{
}
public:
virtual ~SwigPyIterator() {}
// Access iterator method, required by Python
virtual PyObject *value() const = 0;
// Forward iterator method, required by Python
virtual SwigPyIterator *incr(size_t n = 1) = 0;
// Backward iterator method, very common in C++, but not required in Python
virtual SwigPyIterator *decr(size_t /*n*/ = 1)
{
throw stop_iteration();
}
// Random access iterator methods, but not required in Python
virtual ptrdiff_t distance(const SwigPyIterator &/*x*/) const
{
throw std::invalid_argument("operation not supported");
}
virtual bool equal (const SwigPyIterator &/*x*/) const
{
throw std::invalid_argument("operation not supported");
}
// C++ common/needed methods
virtual SwigPyIterator *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;
}
/* Make an alias for Python 3.x */
PyObject *__next__()
{
return next();
}
PyObject *previous()
{
SWIG_PYTHON_THREAD_BEGIN_BLOCK; // disable threads
decr();
PyObject *obj = value();
SWIG_PYTHON_THREAD_END_BLOCK; // re-enable threads
return obj;
}
SwigPyIterator *advance(ptrdiff_t n)
{
return (n > 0) ? incr(n) : decr(-n);
}
bool operator == (const SwigPyIterator& x) const
{
return equal(x);
}
bool operator != (const SwigPyIterator& x) const
{
return ! operator==(x);
}
SwigPyIterator& operator += (ptrdiff_t n)
{
return *advance(n);
}
SwigPyIterator& operator -= (ptrdiff_t n)
{
return *advance(-n);
}
SwigPyIterator* operator + (ptrdiff_t n) const
{
return copy()->advance(n);
}
SwigPyIterator* operator - (ptrdiff_t n) const
{
return copy()->advance(-n);
}
ptrdiff_t operator - (const SwigPyIterator& 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::SwigPyIterator *");
init = 1;
}
return desc;
}
};
#if defined(SWIGPYTHON_BUILTIN)
inline PyObject* make_output_iterator_builtin (PyObject *pyself)
{
Py_INCREF(pyself);
return pyself;
}
#endif
}
SWIGINTERN int
SWIG_AsVal_unsigned_SS_long (PyObject *obj, unsigned long *val)
{
#if PY_VERSION_HEX < 0x03000000
if (PyInt_Check(obj)) {
long v = PyInt_AsLong(obj);
if (v >= 0) {
if (val) *val = v;
return SWIG_OK;
} else {
return SWIG_OverflowError;
}
} else
#endif
if (PyLong_Check(obj)) {
unsigned long v = PyLong_AsUnsignedLong(obj);
if (!PyErr_Occurred()) {
if (val) *val = v;
return SWIG_OK;
} else {
PyErr_Clear();
return SWIG_OverflowError;
}
}
#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;
}
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;
}
#define SWIG_From_long PyLong_FromLong
SWIGINTERNINLINE PyObject *
SWIG_From_ptrdiff_t (ptrdiff_t value)
{
return SWIG_From_long (static_cast< long >(value));
}
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 <algorithm>
#include <vector>
#include <opencv2/core/core.hpp>
#include <sstream>
#include <boost/preprocessor/repetition/repeat_from_to.hpp>
#include <boost/preprocessor/repetition/enum.hpp>
#include <boost/preprocessor/list/for_each.hpp>
/* Macros mapping the Matx channels number to a Boost Preprocessor list[0] with the
* arities of its constructors. Note that to a Matx with N channels, the maximum arity
* of its constructors is N, an there aren't constructors with arities greater than
* 16, neither constructors 15-ary, 14-ary, 13-ary or 11-ary.
*
* [0]: http://www.boost.org/doc/libs/release/libs/preprocessor/doc/data/lists.html
*/
#define _0_CHANNELS_ARITIES_LIST (0, BOOST_PP_NIL)
#define _1_CHANNELS_ARITIES_LIST (1, _0_CHANNELS_ARITIES_LIST)
#define _2_CHANNELS_ARITIES_LIST (2, _1_CHANNELS_ARITIES_LIST)
#define _3_CHANNELS_ARITIES_LIST (3, _2_CHANNELS_ARITIES_LIST)
#define _4_CHANNELS_ARITIES_LIST (4, _3_CHANNELS_ARITIES_LIST)
#define _5_CHANNELS_ARITIES_LIST (5, _4_CHANNELS_ARITIES_LIST)
#define _6_CHANNELS_ARITIES_LIST (6, _5_CHANNELS_ARITIES_LIST)
#define _7_CHANNELS_ARITIES_LIST (7, _6_CHANNELS_ARITIES_LIST)
#define _8_CHANNELS_ARITIES_LIST (8, _7_CHANNELS_ARITIES_LIST)
#define _9_CHANNELS_ARITIES_LIST (9, _8_CHANNELS_ARITIES_LIST)
#define _10_CHANNELS_ARITIES_LIST (10, _9_CHANNELS_ARITIES_LIST)
#define _11_CHANNELS_ARITIES_LIST _10_CHANNELS_ARITIES_LIST
#define _12_CHANNELS_ARITIES_LIST (12, _10_CHANNELS_ARITIES_LIST)
#define _13_CHANNELS_ARITIES_LIST _12_CHANNELS_ARITIES_LIST
#define _14_CHANNELS_ARITIES_LIST _12_CHANNELS_ARITIES_LIST
#define _15_CHANNELS_ARITIES_LIST _12_CHANNELS_ARITIES_LIST
#define _16_CHANNELS_ARITIES_LIST (16, _12_CHANNELS_ARITIES_LIST)
#define ARITIES_LIST(channels) _##channels##_CHANNELS_ARITIES_LIST
#define ARG(z, n, data) arg[n]
#define ELSE_IF_STATEMENT(r, data, n) \
else if (arg.size() == n) \
{ \
return new M(BOOST_PP_ENUM(n, ARG, _)); \
}
#define IF_ELSE_CHAIN(channels) if (false); \
BOOST_PP_LIST_FOR_EACH(ELSE_IF_STATEMENT, _, ARITIES_LIST(channels))
/* Factory to Matx with 10 channels or more.
*
* It should be 16 channels, but as of OpenCV 3.0.0, there are a bug at which only
* Matx's with exactly 12 or 16 channels can call a 12-ary or 16-ary constructors
* respectively.
*/
template <typename M, int Channels=M::channels>
struct Factory
{
static M* construct(std::vector<typename M::value_type> const& arg)
{
IF_ELSE_CHAIN(10)
return NULL;
}
};
#define FACTORY(z, channels, data) \
template <typename M> \
struct Factory<M, channels> \
{ \
static M* construct(std::vector<typename M::value_type> const& arg) \
{ \
IF_ELSE_CHAIN(channels) \
return NULL; \
} \
};
BOOST_PP_REPEAT_FROM_TO(1, 10, FACTORY, _)
template <int A, int B>
struct MinInt
{
enum
{
value = (A < B) ? A : B
};
};
#include <opencv2/core/core.hpp>
#include <sstream>
#include <opencv2/core/core.hpp>
#include <sstream>
#include <opencv2/core/core.hpp>
#include <sstream>
#include <opencv2/core/core.hpp>
#include <sstream>
SWIGINTERNINLINE PyObject*
SWIG_From_unsigned_SS_long (unsigned long value)
{
return (value > LONG_MAX) ?
PyLong_FromUnsignedLong(value) : PyLong_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 int
SWIG_AsVal_bool (PyObject *obj, bool *val)
{
int r;
if (!PyBool_Check(obj))
return SWIG_ERROR;
r = PyObject_IsTrue(obj);
if (r == -1)
return SWIG_ERROR;
if (val) *val = r ? true : false;
return SWIG_OK;
}
SWIGINTERN cv::Mat *new_cv_Mat__SWIG_28(int rows,int cols,int type,ptrdiff_t data){
return new cv::Mat(rows, cols, type, (void*)data);
}
SWIGINTERN std::string cv_Mat___str__(cv::Mat *self){
std::ostringstream s;
s << *self;
return s.str();
}
SWIGINTERNINLINE PyObject *
SWIG_From_std_string (const std::string& s)
{
return SWIG_FromCharPtrAndSize(s.data(), s.size());
}
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_InternalNewPointerObj(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);
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_RichCompareBool(v, w, Py_LT) ? true : false;
/* This may fall into a case of inconsistent
eg. ObjA > ObjX > ObjB
but ObjA < ObjB
*/
if( PyErr_Occurred() && PyErr_ExceptionMatches(PyExc_TypeError) )
{
/* Objects can't be compared, this mostly occurred in Python 3.0 */
/* Compare their ptr directly for a workaround */
res = (v < w);
PyErr_Clear();
}
SWIG_PYTHON_THREAD_END_BLOCK;
return res;
}
};
template <>
struct less <swig::SwigPtr_PyObject>: public binary_function<swig::SwigPtr_PyObject, swig::SwigPtr_PyObject, bool>
{
bool
operator()(const swig::SwigPtr_PyObject& v, const swig::SwigPtr_PyObject& w) const
{
return std::less<PyObject *>()(v, w);
}
};
template <>
struct less <swig::SwigVar_PyObject>: public binary_function<swig::SwigVar_PyObject, swig::SwigVar_PyObject, bool>
{
bool
operator()(const swig::SwigVar_PyObject& v, const swig::SwigVar_PyObject& 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 {
template <class Difference>
inline size_t
check_index(Difference 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");
}
template <class Difference>
void
slice_adjust(Difference i, Difference j, Py_ssize_t step, size_t size, Difference &ii, Difference &jj, bool insert = false) {
if (step == 0) {
throw std::invalid_argument("slice step cannot be zero");
} else if (step > 0) {
// Required range: 0 <= i < size, 0 <= j < size
if (i < 0) {
ii = 0;
} else if (i < (Difference)size) {
ii = i;
} else if (insert && (i >= (Difference)size)) {
ii = (Difference)size;
}
if ( j < 0 ) {
jj = 0;
} else {
jj = (j < (Difference)size) ? j : (Difference)size;
}
} else {
// Required range: -1 <= i < size-1, -1 <= j < size-1
if (i < -1) {
ii = -1;
} else if (i < (Difference) size) {
ii = i;
} else if (i >= (Difference)(size-1)) {
ii = (Difference)(size-1);
}
if (j < -1) {
jj = -1;
} else {
jj = (j < (Difference)size ) ? j : (Difference)(size-1);
}
}
}
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>
inline void
erase(Sequence* seq, const typename Sequence::iterator& position) {
seq->erase(position);
}
template <class Sequence, class Difference>
inline Sequence*
getslice(const Sequence* self, Difference i, Difference j, Py_ssize_t step) {
typename Sequence::size_type size = self->size();
Difference ii = 0;
Difference jj = 0;
swig::slice_adjust(i, j, step, size, ii, jj);
if (step > 0) {
typename Sequence::const_iterator sb = self->begin();
typename Sequence::const_iterator se = self->begin();
std::advance(sb,ii);
std::advance(se,jj);
if (step == 1) {
return new Sequence(sb, se);
} else {
Sequence *sequence = new Sequence();
typename Sequence::const_iterator it = sb;
while (it!=se) {
sequence->push_back(*it);
for (Py_ssize_t c=0; c<step && it!=se; ++c)
it++;
}
return sequence;
}
} else {
Sequence *sequence = new Sequence();
if (ii > jj) {
typename Sequence::const_reverse_iterator sb = self->rbegin();
typename Sequence::const_reverse_iterator se = self->rbegin();
std::advance(sb,size-ii-1);
std::advance(se,size-jj-1);
typename Sequence::const_reverse_iterator it = sb;
while (it!=se) {
sequence->push_back(*it);
for (Py_ssize_t c=0; c<-step && it!=se; ++c)
it++;
}
}
return sequence;
}
}
template <class Sequence, class Difference, class InputSeq>
inline void
setslice(Sequence* self, Difference i, Difference j, Py_ssize_t step, const InputSeq& is = InputSeq()) {
typename Sequence::size_type size = self->size();
Difference ii = 0;
Difference jj = 0;
swig::slice_adjust(i, j, step, size, ii, jj, true);
if (step > 0) {
if (jj < ii)
jj = ii;
if (step == 1) {
size_t ssize = jj - ii;
if (ssize <= is.size()) {
// expanding/staying the same size
typename Sequence::iterator sb = self->begin();
typename InputSeq::const_iterator isit = is.begin();
std::advance(sb,ii);
std::advance(isit, jj - ii);
self->insert(std::copy(is.begin(), isit, sb), isit, is.end());
} else {
// shrinking
typename Sequence::iterator sb = self->begin();
typename Sequence::iterator se = self->begin();
std::advance(sb,ii);
std::advance(se,jj);
self->erase(sb,se);
sb = self->begin();
std::advance(sb,ii);
self->insert(sb, is.begin(), is.end());
}
} else {
size_t replacecount = (jj - ii + step - 1) / step;
if (is.size() != replacecount) {
char msg[1024];
sprintf(msg, "attempt to assign sequence of size %lu to extended slice of size %lu", (unsigned long)is.size(), (unsigned long)replacecount);
throw std::invalid_argument(msg);
}
typename Sequence::const_iterator isit = is.begin();
typename Sequence::iterator it = self->begin();
std::advance(it,ii);
for (size_t rc=0; rc<replacecount; ++rc) {
*it++ = *isit++;
for (Py_ssize_t c=0; c<(step-1) && it != self->end(); ++c)
it++;
}
}
} else {
if (jj > ii)
jj = ii;
size_t replacecount = (ii - jj - step - 1) / -step;
if (is.size() != replacecount) {
char msg[1024];
sprintf(msg, "attempt to assign sequence of size %lu to extended slice of size %lu", (unsigned long)is.size(), (unsigned long)replacecount);
throw std::invalid_argument(msg);
}
typename Sequence::const_iterator isit = is.begin();
typename Sequence::reverse_iterator it = self->rbegin();
std::advance(it,size-ii-1);
for (size_t rc=0; rc<replacecount; ++rc) {
*it++ = *isit++;
for (Py_ssize_t c=0; c<(-step-1) && it != self->rend(); ++c)
it++;
}
}
}
template <class Sequence, class Difference>
inline void
delslice(Sequence* self, Difference i, Difference j, Py_ssize_t step) {
typename Sequence::size_type size = self->size();
Difference ii = 0;
Difference jj = 0;
swig::slice_adjust(i, j, step, size, ii, jj, true);
if (step > 0) {
if (jj > ii) {
typename Sequence::iterator sb = self->begin();
std::advance(sb,ii);
if (step == 1) {
typename Sequence::iterator se = self->begin();
std::advance(se,jj);
self->erase(sb,se);
} else {
typename Sequence::iterator it = sb;
size_t delcount = (jj - ii + step - 1) / step;
while (delcount) {
it = self->erase(it);
for (Py_ssize_t c=0; c<(step-1) && it != self->end(); ++c)
it++;
delcount--;
}
}
}
} else {
if (ii > jj) {
typename Sequence::reverse_iterator sb = self->rbegin();
std::advance(sb,size-ii-1);
typename Sequence::reverse_iterator it = sb;
size_t delcount = (ii - jj - step - 1) / -step;
while (delcount) {
it = typename Sequence::reverse_iterator(self->erase((++it).base()));
for (Py_ssize_t c=0; c<(-step-1) && it != self->rend(); ++c)
it++;
delcount--;
}
}
}
}
}
#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 SwigPyIterator_T : public SwigPyIterator
{
public:
typedef OutIterator out_iterator;
typedef typename std::iterator_traits<out_iterator>::value_type value_type;
typedef SwigPyIterator_T<out_iterator> self_type;
SwigPyIterator_T(out_iterator curr, PyObject *seq)
: SwigPyIterator(seq), current(curr)
{
}
const out_iterator& get_current() const
{
return current;
}
bool equal (const SwigPyIterator &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 SwigPyIterator &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 SwigPyIteratorOpen_T : public SwigPyIterator_T<OutIterator>
{
public:
FromOper from;
typedef OutIterator out_iterator;
typedef ValueType value_type;
typedef SwigPyIterator_T<out_iterator> base;
typedef SwigPyIteratorOpen_T<OutIterator, ValueType, FromOper> self_type;
SwigPyIteratorOpen_T(out_iterator curr, PyObject *seq)
: SwigPyIterator_T<OutIterator>(curr, seq)
{
}
PyObject *value() const {
return from(static_cast<const value_type&>(*(base::current)));
}
SwigPyIterator *copy() const
{
return new self_type(*this);
}
SwigPyIterator *incr(size_t n = 1)
{
while (n--) {
++base::current;
}
return this;
}
SwigPyIterator *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 SwigPyIteratorClosed_T : public SwigPyIterator_T<OutIterator>
{
public:
FromOper from;
typedef OutIterator out_iterator;
typedef ValueType value_type;
typedef SwigPyIterator_T<out_iterator> base;
typedef SwigPyIteratorClosed_T<OutIterator, ValueType, FromOper> self_type;
SwigPyIteratorClosed_T(out_iterator curr, out_iterator first, out_iterator last, PyObject *seq)
: SwigPyIterator_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)));
}
}
SwigPyIterator *copy() const
{
return new self_type(*this);
}
SwigPyIterator *incr(size_t n = 1)
{
while (n--) {
if (base::current == end) {
throw stop_iteration();
} else {
++base::current;
}
}
return this;
}
SwigPyIterator *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 SwigPyIterator*
make_output_iterator(const OutIter& current, const OutIter& begin,const OutIter& end, PyObject *seq = 0)
{
return new SwigPyIteratorClosed_T<OutIter>(current, begin, end, seq);
}
template<typename OutIter>
inline SwigPyIterator*
make_output_iterator(const OutIter& current, PyObject *seq = 0)
{
return new SwigPyIteratorOpen_T<OutIter>(current, seq);
}
}
namespace swig
{
template <class T>
struct SwigPySequence_Ref
{
SwigPySequence_Ref(PyObject* seq, Py_ssize_t index)
: _seq(seq), _index(index)
{
}
operator T () const
{
swig::SwigVar_PyObject 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 ", (int)_index);
if (!PyErr_Occurred()) {
::SWIG_Error(SWIG_TypeError, swig::type_name<T>());
}
SWIG_Python_AddErrorMsg(msg);
SWIG_Python_AddErrorMsg(e.what());
throw;
}
}
SwigPySequence_Ref& operator=(const T& v)
{
PySequence_SetItem(_seq, _index, swig::from<T>(v));
return *this;
}
private:
PyObject* _seq;
Py_ssize_t _index;
};
template <class T>
struct SwigPySequence_ArrowProxy
{
SwigPySequence_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 SwigPySequence_InputIterator
{
typedef SwigPySequence_InputIterator<T, Reference > self;
typedef std::random_access_iterator_tag iterator_category;
typedef Reference reference;
typedef T value_type;
typedef T* pointer;
typedef Py_ssize_t difference_type;
SwigPySequence_InputIterator()
{
}
SwigPySequence_InputIterator(PyObject* seq, Py_ssize_t index)
: _seq(seq), _index(index)
{
}
reference operator*() const
{
return reference(_seq, _index);
}
SwigPySequence_ArrowProxy<T>
operator->() const {
return SwigPySequence_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;
};
// STL container wrapper around a Python sequence
template <class T>
struct SwigPySequence_Cont
{
typedef SwigPySequence_Ref<T> reference;
typedef const SwigPySequence_Ref<T> const_reference;
typedef T value_type;
typedef T* pointer;
typedef Py_ssize_t difference_type;
typedef size_t size_type;
typedef const pointer const_pointer;
typedef SwigPySequence_InputIterator<T, reference> iterator;
typedef SwigPySequence_InputIterator<T, const_reference> const_iterator;
SwigPySequence_Cont(PyObject* seq) : _seq(0)
{
if (!PySequence_Check(seq)) {
throw std::invalid_argument("a sequence is expected");
}
_seq = seq;
Py_INCREF(_seq);
}
~SwigPySequence_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
{
Py_ssize_t s = size();
for (Py_ssize_t i = 0; i < s; ++i) {
swig::SwigVar_PyObject item = PySequence_GetItem(_seq, i);
if (!swig::check<value_type>(item)) {
if (set_err) {
char msg[1024];
sprintf(msg, "in sequence element %d", (int)i);
SWIG_Error(SWIG_RuntimeError, msg);
}
return false;
}
}
return true;
}
private:
PyObject* _seq;
};
}
SWIGINTERN int
SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val)
{
unsigned long v;
int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
if (SWIG_IsOK(res)) {
if ((v > UCHAR_MAX)) {
return SWIG_OverflowError;
} else {
if (val) *val = static_cast< unsigned char >(v);
}
}
return res;
}
SWIGINTERNINLINE PyObject *
SWIG_From_unsigned_SS_char (unsigned char value)
{
return SWIG_From_unsigned_SS_long (value);
}
namespace swig {
template <> struct traits< unsigned char > {
typedef value_category category;
static const char* type_name() { return"unsigned char"; }
};
template <> struct traits_asval< unsigned char > {
typedef unsigned char value_type;
static int asval(PyObject *obj, value_type *val) {
return SWIG_AsVal_unsigned_SS_char (obj, val);
}
};
template <> struct traits_from< unsigned char > {
typedef unsigned char value_type;
static PyObject *from(const value_type& val) {
return SWIG_From_unsigned_SS_char (val);
}
};
}
namespace swig {
template <class SwigPySeq, class Seq>
inline void
assign(const SwigPySeq& swigpyseq, Seq* seq) {
// seq->assign(swigpyseq.begin(), swigpyseq.end()); // not used as not always implemented
typedef typename SwigPySeq::value_type value_type;
typename SwigPySeq::const_iterator it = swigpyseq.begin();
for (;it != swigpyseq.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 {
SwigPySequence_Cont<value_type> swigpyseq(obj);
if (seq) {
sequence *pseq = new sequence();
assign(swigpyseq, pseq);
*seq = pseq;
return SWIG_NEWOBJ;
} else {
return swigpyseq.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((Py_ssize_t)size);
Py_ssize_t 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< unsigned char, std::allocator< unsigned char > > > {
typedef pointer_category category;
static const char* type_name() {
return "std::vector<" "unsigned char" "," "std::allocator< unsigned char >" " >";
}
};
}
SWIGINTERN swig::SwigPyIterator *std_vector_Sl_uint8_t_Sg__iterator(std::vector< uint8_t > *self,PyObject **PYTHON_SELF){
return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
}
SWIGINTERN bool std_vector_Sl_uint8_t_Sg____nonzero__(std::vector< uint8_t > const *self){
return !(self->empty());
}
SWIGINTERN bool std_vector_Sl_uint8_t_Sg____bool__(std::vector< uint8_t > const *self){
return !(self->empty());
}
SWIGINTERN std::vector< unsigned char >::size_type std_vector_Sl_uint8_t_Sg____len__(std::vector< uint8_t > const *self){
return self->size();
}
SWIGINTERN std::vector< unsigned char,std::allocator< unsigned char > > *std_vector_Sl_uint8_t_Sg____getslice__(std::vector< uint8_t > *self,std::vector< unsigned char >::difference_type i,std::vector< unsigned char >::difference_type j){
return swig::getslice(self, i, j, 1);
}
SWIGINTERN void std_vector_Sl_uint8_t_Sg____setslice____SWIG_0(std::vector< uint8_t > *self,std::vector< unsigned char >::difference_type i,std::vector< unsigned char >::difference_type j){
swig::setslice(self, i, j, 1, std::vector< unsigned char,std::allocator< unsigned char > >());
}
SWIGINTERN void std_vector_Sl_uint8_t_Sg____setslice____SWIG_1(std::vector< uint8_t > *self,std::vector< unsigned char >::difference_type i,std::vector< unsigned char >::difference_type j,std::vector< unsigned char,std::allocator< unsigned char > > const &v){
swig::setslice(self, i, j, 1, v);
}
SWIGINTERN void std_vector_Sl_uint8_t_Sg____delslice__(std::vector< uint8_t > *self,std::vector< unsigned char >::difference_type i,std::vector< unsigned char >::difference_type j){
swig::delslice(self, i, j, 1);
}
SWIGINTERN void std_vector_Sl_uint8_t_Sg____delitem____SWIG_0(std::vector< uint8_t > *self,std::vector< unsigned char >::difference_type i){
swig::erase(self, swig::getpos(self, i));
}
SWIGINTERN std::vector< unsigned char,std::allocator< unsigned char > > *std_vector_Sl_uint8_t_Sg____getitem____SWIG_0(std::vector< uint8_t > *self,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return NULL;
}
PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< unsigned char,std::allocator< unsigned char > >::difference_type id = i;
std::vector< unsigned char,std::allocator< unsigned char > >::difference_type jd = j;
return swig::getslice(self, id, jd, step);
}
SWIGINTERN void std_vector_Sl_uint8_t_Sg____setitem____SWIG_0(std::vector< uint8_t > *self,PySliceObject *slice,std::vector< unsigned char,std::allocator< unsigned char > > const &v){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< unsigned char,std::allocator< unsigned char > >::difference_type id = i;
std::vector< unsigned char,std::allocator< unsigned char > >::difference_type jd = j;
swig::setslice(self, id, jd, step, v);
}
SWIGINTERN void std_vector_Sl_uint8_t_Sg____setitem____SWIG_1(std::vector< uint8_t > *self,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< unsigned char,std::allocator< unsigned char > >::difference_type id = i;
std::vector< unsigned char,std::allocator< unsigned char > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
}
SWIGINTERN void std_vector_Sl_uint8_t_Sg____delitem____SWIG_1(std::vector< uint8_t > *self,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< unsigned char,std::allocator< unsigned char > >::difference_type id = i;
std::vector< unsigned char,std::allocator< unsigned char > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
}
SWIGINTERN std::vector< unsigned char >::value_type const &std_vector_Sl_uint8_t_Sg____getitem____SWIG_1(std::vector< uint8_t > const *self,std::vector< unsigned char >::difference_type i){
return *(swig::cgetpos(self, i));
}
SWIGINTERN void std_vector_Sl_uint8_t_Sg____setitem____SWIG_2(std::vector< uint8_t > *self,std::vector< unsigned char >::difference_type i,std::vector< unsigned char >::value_type const &x){
*(swig::getpos(self,i)) = x;
}
SWIGINTERN std::vector< unsigned char >::value_type std_vector_Sl_uint8_t_Sg__pop(std::vector< uint8_t > *self){
if (self->size() == 0)
throw std::out_of_range("pop from empty container");
std::vector< unsigned char,std::allocator< unsigned char > >::value_type x = self->back();
self->pop_back();
return x;
}
SWIGINTERN void std_vector_Sl_uint8_t_Sg__append(std::vector< uint8_t > *self,std::vector< unsigned char >::value_type const &x){
self->push_back(x);
}
SWIGINTERN std::vector< unsigned char >::iterator std_vector_Sl_uint8_t_Sg__erase__SWIG_0(std::vector< uint8_t > *self,std::vector< unsigned char >::iterator pos){ return self->erase(pos); }
SWIGINTERN std::vector< unsigned char >::iterator std_vector_Sl_uint8_t_Sg__erase__SWIG_1(std::vector< uint8_t > *self,std::vector< unsigned char >::iterator first,std::vector< unsigned char >::iterator last){ return self->erase(first, last); }
SWIGINTERN std::vector< unsigned char >::iterator std_vector_Sl_uint8_t_Sg__insert__SWIG_0(std::vector< uint8_t > *self,std::vector< unsigned char >::iterator pos,std::vector< unsigned char >::value_type const &x){ return self->insert(pos, x); }
SWIGINTERN void std_vector_Sl_uint8_t_Sg__insert__SWIG_1(std::vector< uint8_t > *self,std::vector< unsigned char >::iterator pos,std::vector< unsigned char >::size_type n,std::vector< unsigned char >::value_type const &x){ self->insert(pos, n, x); }
#define SWIG_From_double PyFloat_FromDouble
SWIGINTERN cv::Matx< uint8_t,2,1 > *new_cv_Matx_Sl_uint8_t_Sc_2_Sc_1_Sg___SWIG_6(std::vector< cv::Matx< unsigned char,2,1 >::value_type,std::allocator< cv::Matx< uint8_t,2,1 >::value_type > > arg){
return Factory< cv::Matx< uint8_t,2,1 > >::construct(arg);
}
SWIGINTERN std::string cv_Matx_Sl_uint8_t_Sc_2_Sc_1_Sg____str__(cv::Matx< uint8_t,2,1 > *self){
std::ostringstream s;
s << *self;
return s.str();
}
SWIGINTERN cv::Vec< uint8_t,2 > *new_cv_Vec_Sl_uint8_t_Sc_2_Sg___SWIG_4(std::vector< cv::Vec< unsigned char,2 >::value_type,std::allocator< cv::Vec< uint8_t,2 >::value_type > > arg){
return Factory< cv::Vec< uint8_t,2 > >::construct(arg);
}
SWIGINTERN std::string cv_Vec_Sl_uint8_t_Sc_2_Sg____str__(cv::Vec< uint8_t,2 > *self){
std::ostringstream s;
s << *self;
return s.str();
}
SWIGINTERN cv::Matx< uint8_t,3,1 > *new_cv_Matx_Sl_uint8_t_Sc_3_Sc_1_Sg___SWIG_6(std::vector< cv::Matx< unsigned char,3,1 >::value_type,std::allocator< cv::Matx< uint8_t,3,1 >::value_type > > arg){
return Factory< cv::Matx< uint8_t,3,1 > >::construct(arg);
}
SWIGINTERN std::string cv_Matx_Sl_uint8_t_Sc_3_Sc_1_Sg____str__(cv::Matx< uint8_t,3,1 > *self){
std::ostringstream s;
s << *self;
return s.str();
}
SWIGINTERN cv::Vec< uint8_t,3 > *new_cv_Vec_Sl_uint8_t_Sc_3_Sg___SWIG_4(std::vector< cv::Vec< unsigned char,3 >::value_type,std::allocator< cv::Vec< uint8_t,3 >::value_type > > arg){
return Factory< cv::Vec< uint8_t,3 > >::construct(arg);
}
SWIGINTERN std::string cv_Vec_Sl_uint8_t_Sc_3_Sg____str__(cv::Vec< uint8_t,3 > *self){
std::ostringstream s;
s << *self;
return s.str();
}
SWIGINTERN cv::Matx< uint8_t,4,1 > *new_cv_Matx_Sl_uint8_t_Sc_4_Sc_1_Sg___SWIG_6(std::vector< cv::Matx< unsigned char,4,1 >::value_type,std::allocator< cv::Matx< uint8_t,4,1 >::value_type > > arg){
return Factory< cv::Matx< uint8_t,4,1 > >::construct(arg);
}
SWIGINTERN std::string cv_Matx_Sl_uint8_t_Sc_4_Sc_1_Sg____str__(cv::Matx< uint8_t,4,1 > *self){
std::ostringstream s;
s << *self;
return s.str();
}
SWIGINTERN cv::Vec< uint8_t,4 > *new_cv_Vec_Sl_uint8_t_Sc_4_Sg___SWIG_4(std::vector< cv::Vec< unsigned char,4 >::value_type,std::allocator< cv::Vec< uint8_t,4 >::value_type > > arg){
return Factory< cv::Vec< uint8_t,4 > >::construct(arg);
}
SWIGINTERN std::string cv_Vec_Sl_uint8_t_Sc_4_Sg____str__(cv::Vec< uint8_t,4 > *self){
std::ostringstream s;
s << *self;
return s.str();
}
SWIGINTERN int
SWIG_AsVal_short (PyObject * obj, short *val)
{
long v;
int res = SWIG_AsVal_long (obj, &v);
if (SWIG_IsOK(res)) {
if ((v < SHRT_MIN || v > SHRT_MAX)) {
return SWIG_OverflowError;
} else {
if (val) *val = static_cast< short >(v);
}
}
return res;
}
SWIGINTERNINLINE PyObject *
SWIG_From_short (short value)
{
return SWIG_From_long (value);
}
namespace swig {
template <> struct traits< short > {
typedef value_category category;
static const char* type_name() { return"short"; }
};
template <> struct traits_asval< short > {
typedef short value_type;
static int asval(PyObject *obj, value_type *val) {
return SWIG_AsVal_short (obj, val);
}
};
template <> struct traits_from< short > {
typedef short value_type;
static PyObject *from(const value_type& val) {
return SWIG_From_short (val);
}
};
}
namespace swig {
template <> struct traits<std::vector< short, std::allocator< short > > > {
typedef pointer_category category;
static const char* type_name() {
return "std::vector<" "short" "," "std::allocator< short >" " >";
}
};
}
SWIGINTERN swig::SwigPyIterator *std_vector_Sl_short_Sg__iterator(std::vector< short > *self,PyObject **PYTHON_SELF){
return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
}
SWIGINTERN bool std_vector_Sl_short_Sg____nonzero__(std::vector< short > const *self){
return !(self->empty());
}
SWIGINTERN bool std_vector_Sl_short_Sg____bool__(std::vector< short > const *self){
return !(self->empty());
}
SWIGINTERN std::vector< short >::size_type std_vector_Sl_short_Sg____len__(std::vector< short > const *self){
return self->size();
}
SWIGINTERN std::vector< short,std::allocator< short > > *std_vector_Sl_short_Sg____getslice__(std::vector< short > *self,std::vector< short >::difference_type i,std::vector< short >::difference_type j){
return swig::getslice(self, i, j, 1);
}
SWIGINTERN void std_vector_Sl_short_Sg____setslice____SWIG_0(std::vector< short > *self,std::vector< short >::difference_type i,std::vector< short >::difference_type j){
swig::setslice(self, i, j, 1, std::vector< short,std::allocator< short > >());
}
SWIGINTERN void std_vector_Sl_short_Sg____setslice____SWIG_1(std::vector< short > *self,std::vector< short >::difference_type i,std::vector< short >::difference_type j,std::vector< short,std::allocator< short > > const &v){
swig::setslice(self, i, j, 1, v);
}
SWIGINTERN void std_vector_Sl_short_Sg____delslice__(std::vector< short > *self,std::vector< short >::difference_type i,std::vector< short >::difference_type j){
swig::delslice(self, i, j, 1);
}
SWIGINTERN void std_vector_Sl_short_Sg____delitem____SWIG_0(std::vector< short > *self,std::vector< short >::difference_type i){
swig::erase(self, swig::getpos(self, i));
}
SWIGINTERN std::vector< short,std::allocator< short > > *std_vector_Sl_short_Sg____getitem____SWIG_0(std::vector< short > *self,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return NULL;
}
PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< short,std::allocator< short > >::difference_type id = i;
std::vector< short,std::allocator< short > >::difference_type jd = j;
return swig::getslice(self, id, jd, step);
}
SWIGINTERN void std_vector_Sl_short_Sg____setitem____SWIG_0(std::vector< short > *self,PySliceObject *slice,std::vector< short,std::allocator< short > > const &v){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< short,std::allocator< short > >::difference_type id = i;
std::vector< short,std::allocator< short > >::difference_type jd = j;
swig::setslice(self, id, jd, step, v);
}
SWIGINTERN void std_vector_Sl_short_Sg____setitem____SWIG_1(std::vector< short > *self,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< short,std::allocator< short > >::difference_type id = i;
std::vector< short,std::allocator< short > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
}
SWIGINTERN void std_vector_Sl_short_Sg____delitem____SWIG_1(std::vector< short > *self,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< short,std::allocator< short > >::difference_type id = i;
std::vector< short,std::allocator< short > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
}
SWIGINTERN std::vector< short >::value_type const &std_vector_Sl_short_Sg____getitem____SWIG_1(std::vector< short > const *self,std::vector< short >::difference_type i){
return *(swig::cgetpos(self, i));
}
SWIGINTERN void std_vector_Sl_short_Sg____setitem____SWIG_2(std::vector< short > *self,std::vector< short >::difference_type i,std::vector< short >::value_type const &x){
*(swig::getpos(self,i)) = x;
}
SWIGINTERN std::vector< short >::value_type std_vector_Sl_short_Sg__pop(std::vector< short > *self){
if (self->size() == 0)
throw std::out_of_range("pop from empty container");
std::vector< short,std::allocator< short > >::value_type x = self->back();
self->pop_back();
return x;
}
SWIGINTERN void std_vector_Sl_short_Sg__append(std::vector< short > *self,std::vector< short >::value_type const &x){
self->push_back(x);
}
SWIGINTERN std::vector< short >::iterator std_vector_Sl_short_Sg__erase__SWIG_0(std::vector< short > *self,std::vector< short >::iterator pos){ return self->erase(pos); }
SWIGINTERN std::vector< short >::iterator std_vector_Sl_short_Sg__erase__SWIG_1(std::vector< short > *self,std::vector< short >::iterator first,std::vector< short >::iterator last){ return self->erase(first, last); }
SWIGINTERN std::vector< short >::iterator std_vector_Sl_short_Sg__insert__SWIG_0(std::vector< short > *self,std::vector< short >::iterator pos,std::vector< short >::value_type const &x){ return self->insert(pos, x); }
SWIGINTERN void std_vector_Sl_short_Sg__insert__SWIG_1(std::vector< short > *self,std::vector< short >::iterator pos,std::vector< short >::size_type n,std::vector< short >::value_type const &x){ self->insert(pos, n, x); }
SWIGINTERN cv::Matx< short,2,1 > *new_cv_Matx_Sl_short_Sc_2_Sc_1_Sg___SWIG_6(std::vector< cv::Matx< short,2,1 >::value_type,std::allocator< cv::Matx< short,2,1 >::value_type > > arg){
return Factory< cv::Matx< short,2,1 > >::construct(arg);
}
SWIGINTERN std::string cv_Matx_Sl_short_Sc_2_Sc_1_Sg____str__(cv::Matx< short,2,1 > *self){
std::ostringstream s;
s << *self;
return s.str();
}
SWIGINTERN cv::Vec< short,2 > *new_cv_Vec_Sl_short_Sc_2_Sg___SWIG_4(std::vector< cv::Vec< short,2 >::value_type,std::allocator< cv::Vec< short,2 >::value_type > > arg){
return Factory< cv::Vec< short,2 > >::construct(arg);
}
SWIGINTERN std::string cv_Vec_Sl_short_Sc_2_Sg____str__(cv::Vec< short,2 > *self){
std::ostringstream s;
s << *self;
return s.str();
}
SWIGINTERN cv::Matx< short,3,1 > *new_cv_Matx_Sl_short_Sc_3_Sc_1_Sg___SWIG_6(std::vector< cv::Matx< short,3,1 >::value_type,std::allocator< cv::Matx< short,3,1 >::value_type > > arg){
return Factory< cv::Matx< short,3,1 > >::construct(arg);
}
SWIGINTERN std::string cv_Matx_Sl_short_Sc_3_Sc_1_Sg____str__(cv::Matx< short,3,1 > *self){
std::ostringstream s;
s << *self;
return s.str();
}
SWIGINTERN cv::Vec< short,3 > *new_cv_Vec_Sl_short_Sc_3_Sg___SWIG_4(std::vector< cv::Vec< short,3 >::value_type,std::allocator< cv::Vec< short,3 >::value_type > > arg){
return Factory< cv::Vec< short,3 > >::construct(arg);
}
SWIGINTERN std::string cv_Vec_Sl_short_Sc_3_Sg____str__(cv::Vec< short,3 > *self){
std::ostringstream s;
s << *self;
return s.str();
}
SWIGINTERN cv::Matx< short,4,1 > *new_cv_Matx_Sl_short_Sc_4_Sc_1_Sg___SWIG_6(std::vector< cv::Matx< short,4,1 >::value_type,std::allocator< cv::Matx< short,4,1 >::value_type > > arg){
return Factory< cv::Matx< short,4,1 > >::construct(arg);
}
SWIGINTERN std::string cv_Matx_Sl_short_Sc_4_Sc_1_Sg____str__(cv::Matx< short,4,1 > *self){
std::ostringstream s;
s << *self;
return s.str();
}
SWIGINTERN cv::Vec< short,4 > *new_cv_Vec_Sl_short_Sc_4_Sg___SWIG_4(std::vector< cv::Vec< short,4 >::value_type,std::allocator< cv::Vec< short,4 >::value_type > > arg){
return Factory< cv::Vec< short,4 > >::construct(arg);
}
SWIGINTERN std::string cv_Vec_Sl_short_Sc_4_Sg____str__(cv::Vec< short,4 > *self){
std::ostringstream s;
s << *self;
return s.str();
}
namespace swig {
template <> struct traits< ushort > {
typedef pointer_category category;
static const char* type_name() { return"ushort"; }
};
}
namespace swig {
template <> struct traits<std::vector< ushort, std::allocator< ushort > > > {
typedef pointer_category category;
static const char* type_name() {
return "std::vector<" "ushort" "," "std::allocator< ushort >" " >";
}
};
}
SWIGINTERN swig::SwigPyIterator *std_vector_Sl_ushort_Sg__iterator(std::vector< ushort > *self,PyObject **PYTHON_SELF){
return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
}
SWIGINTERN bool std_vector_Sl_ushort_Sg____nonzero__(std::vector< ushort > const *self){
return !(self->empty());
}
SWIGINTERN bool std_vector_Sl_ushort_Sg____bool__(std::vector< ushort > const *self){
return !(self->empty());
}
SWIGINTERN std::vector< ushort >::size_type std_vector_Sl_ushort_Sg____len__(std::vector< ushort > const *self){
return self->size();
}
SWIGINTERN std::vector< ushort,std::allocator< ushort > > *std_vector_Sl_ushort_Sg____getslice__(std::vector< ushort > *self,std::vector< ushort >::difference_type i,std::vector< ushort >::difference_type j){
return swig::getslice(self, i, j, 1);
}
SWIGINTERN void std_vector_Sl_ushort_Sg____setslice____SWIG_0(std::vector< ushort > *self,std::vector< ushort >::difference_type i,std::vector< ushort >::difference_type j){
swig::setslice(self, i, j, 1, std::vector< ushort,std::allocator< ushort > >());
}
SWIGINTERN void std_vector_Sl_ushort_Sg____setslice____SWIG_1(std::vector< ushort > *self,std::vector< ushort >::difference_type i,std::vector< ushort >::difference_type j,std::vector< ushort,std::allocator< ushort > > const &v){
swig::setslice(self, i, j, 1, v);
}
SWIGINTERN void std_vector_Sl_ushort_Sg____delslice__(std::vector< ushort > *self,std::vector< ushort >::difference_type i,std::vector< ushort >::difference_type j){
swig::delslice(self, i, j, 1);
}
SWIGINTERN void std_vector_Sl_ushort_Sg____delitem____SWIG_0(std::vector< ushort > *self,std::vector< ushort >::difference_type i){
swig::erase(self, swig::getpos(self, i));
}
SWIGINTERN std::vector< ushort,std::allocator< ushort > > *std_vector_Sl_ushort_Sg____getitem____SWIG_0(std::vector< ushort > *self,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return NULL;
}
PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< ushort,std::allocator< ushort > >::difference_type id = i;
std::vector< ushort,std::allocator< ushort > >::difference_type jd = j;
return swig::getslice(self, id, jd, step);
}
SWIGINTERN void std_vector_Sl_ushort_Sg____setitem____SWIG_0(std::vector< ushort > *self,PySliceObject *slice,std::vector< ushort,std::allocator< ushort > > const &v){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< ushort,std::allocator< ushort > >::difference_type id = i;
std::vector< ushort,std::allocator< ushort > >::difference_type jd = j;
swig::setslice(self, id, jd, step, v);
}
SWIGINTERN void std_vector_Sl_ushort_Sg____setitem____SWIG_1(std::vector< ushort > *self,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< ushort,std::allocator< ushort > >::difference_type id = i;
std::vector< ushort,std::allocator< ushort > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
}
SWIGINTERN void std_vector_Sl_ushort_Sg____delitem____SWIG_1(std::vector< ushort > *self,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< ushort,std::allocator< ushort > >::difference_type id = i;
std::vector< ushort,std::allocator< ushort > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
}
SWIGINTERN std::vector< ushort >::value_type const &std_vector_Sl_ushort_Sg____getitem____SWIG_1(std::vector< ushort > const *self,std::vector< ushort >::difference_type i){
return *(swig::cgetpos(self, i));
}
SWIGINTERN void std_vector_Sl_ushort_Sg____setitem____SWIG_2(std::vector< ushort > *self,std::vector< ushort >::difference_type i,std::vector< ushort >::value_type const &x){
*(swig::getpos(self,i)) = x;
}
SWIGINTERN std::vector< ushort >::value_type std_vector_Sl_ushort_Sg__pop(std::vector< ushort > *self){
if (self->size() == 0)
throw std::out_of_range("pop from empty container");
std::vector< ushort,std::allocator< ushort > >::value_type x = self->back();
self->pop_back();
return x;
}
SWIGINTERN void std_vector_Sl_ushort_Sg__append(std::vector< ushort > *self,std::vector< ushort >::value_type const &x){
self->push_back(x);
}
SWIGINTERN std::vector< ushort >::iterator std_vector_Sl_ushort_Sg__erase__SWIG_0(std::vector< ushort > *self,std::vector< ushort >::iterator pos){ return self->erase(pos); }
SWIGINTERN std::vector< ushort >::iterator std_vector_Sl_ushort_Sg__erase__SWIG_1(std::vector< ushort > *self,std::vector< ushort >::iterator first,std::vector< ushort >::iterator last){ return self->erase(first, last); }
SWIGINTERN std::vector< ushort >::iterator std_vector_Sl_ushort_Sg__insert__SWIG_0(std::vector< ushort > *self,std::vector< ushort >::iterator pos,std::vector< ushort >::value_type const &x){ return self->insert(pos, x); }
SWIGINTERN void std_vector_Sl_ushort_Sg__insert__SWIG_1(std::vector< ushort > *self,std::vector< ushort >::iterator pos,std::vector< ushort >::size_type n,std::vector< ushort >::value_type const &x){ self->insert(pos, n, x); }
SWIGINTERN cv::Matx< ushort,2,1 > *new_cv_Matx_Sl_ushort_Sc_2_Sc_1_Sg___SWIG_6(std::vector< cv::Matx< ushort,2,1 >::value_type,std::allocator< cv::Matx< ushort,2,1 >::value_type > > arg){
return Factory< cv::Matx< ushort,2,1 > >::construct(arg);
}
SWIGINTERN std::string cv_Matx_Sl_ushort_Sc_2_Sc_1_Sg____str__(cv::Matx< ushort,2,1 > *self){
std::ostringstream s;
s << *self;
return s.str();
}
SWIGINTERN cv::Vec< ushort,2 > *new_cv_Vec_Sl_ushort_Sc_2_Sg___SWIG_4(std::vector< cv::Vec< ushort,2 >::value_type,std::allocator< cv::Vec< ushort,2 >::value_type > > arg){
return Factory< cv::Vec< ushort,2 > >::construct(arg);
}
SWIGINTERN std::string cv_Vec_Sl_ushort_Sc_2_Sg____str__(cv::Vec< ushort,2 > *self){
std::ostringstream s;
s << *self;
return s.str();
}
SWIGINTERN cv::Matx< ushort,3,1 > *new_cv_Matx_Sl_ushort_Sc_3_Sc_1_Sg___SWIG_6(std::vector< cv::Matx< ushort,3,1 >::value_type,std::allocator< cv::Matx< ushort,3,1 >::value_type > > arg){
return Factory< cv::Matx< ushort,3,1 > >::construct(arg);
}
SWIGINTERN std::string cv_Matx_Sl_ushort_Sc_3_Sc_1_Sg____str__(cv::Matx< ushort,3,1 > *self){
std::ostringstream s;
s << *self;
return s.str();
}
SWIGINTERN cv::Vec< ushort,3 > *new_cv_Vec_Sl_ushort_Sc_3_Sg___SWIG_4(std::vector< cv::Vec< ushort,3 >::value_type,std::allocator< cv::Vec< ushort,3 >::value_type > > arg){
return Factory< cv::Vec< ushort,3 > >::construct(arg);
}
SWIGINTERN std::string cv_Vec_Sl_ushort_Sc_3_Sg____str__(cv::Vec< ushort,3 > *self){
std::ostringstream s;
s << *self;
return s.str();
}
SWIGINTERN cv::Matx< ushort,4,1 > *new_cv_Matx_Sl_ushort_Sc_4_Sc_1_Sg___SWIG_6(std::vector< cv::Matx< ushort,4,1 >::value_type,std::allocator< cv::Matx< ushort,4,1 >::value_type > > arg){
return Factory< cv::Matx< ushort,4,1 > >::construct(arg);
}
SWIGINTERN std::string cv_Matx_Sl_ushort_Sc_4_Sc_1_Sg____str__(cv::Matx< ushort,4,1 > *self){
std::ostringstream s;
s << *self;
return s.str();
}
SWIGINTERN cv::Vec< ushort,4 > *new_cv_Vec_Sl_ushort_Sc_4_Sg___SWIG_4(std::vector< cv::Vec< ushort,4 >::value_type,std::allocator< cv::Vec< ushort,4 >::value_type > > arg){
return Factory< cv::Vec< ushort,4 > >::construct(arg);
}
SWIGINTERN std::string cv_Vec_Sl_ushort_Sc_4_Sg____str__(cv::Vec< ushort,4 > *self){
std::ostringstream s;
s << *self;
return s.str();
}
namespace swig {
template <> struct traits< int > {
typedef value_category category;
static const char* type_name() { return"int"; }
};
template <> struct traits_asval< int > {
typedef int value_type;
static int asval(PyObject *obj, value_type *val) {
return SWIG_AsVal_int (obj, val);
}
};
template <> struct traits_from< int > {
typedef int value_type;
static PyObject *from(const value_type& val) {
return SWIG_From_int (val);
}
};
}
namespace swig {
template <> struct traits<std::vector< int, std::allocator< int > > > {
typedef pointer_category category;
static const char* type_name() {
return "std::vector<" "int" "," "std::allocator< int >" " >";
}
};
}
SWIGINTERN swig::SwigPyIterator *std_vector_Sl_int_Sg__iterator(std::vector< int > *self,PyObject **PYTHON_SELF){
return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
}
SWIGINTERN bool std_vector_Sl_int_Sg____nonzero__(std::vector< int > const *self){
return !(self->empty());
}
SWIGINTERN bool std_vector_Sl_int_Sg____bool__(std::vector< int > const *self){
return !(self->empty());
}
SWIGINTERN std::vector< int >::size_type std_vector_Sl_int_Sg____len__(std::vector< int > const *self){
return self->size();
}
SWIGINTERN std::vector< int,std::allocator< int > > *std_vector_Sl_int_Sg____getslice__(std::vector< int > *self,std::vector< int >::difference_type i,std::vector< int >::difference_type j){
return swig::getslice(self, i, j, 1);
}
SWIGINTERN void std_vector_Sl_int_Sg____setslice____SWIG_0(std::vector< int > *self,std::vector< int >::difference_type i,std::vector< int >::difference_type j){
swig::setslice(self, i, j, 1, std::vector< int,std::allocator< int > >());
}
SWIGINTERN void std_vector_Sl_int_Sg____setslice____SWIG_1(std::vector< int > *self,std::vector< int >::difference_type i,std::vector< int >::difference_type j,std::vector< int,std::allocator< int > > const &v){
swig::setslice(self, i, j, 1, v);
}
SWIGINTERN void std_vector_Sl_int_Sg____delslice__(std::vector< int > *self,std::vector< int >::difference_type i,std::vector< int >::difference_type j){
swig::delslice(self, i, j, 1);
}
SWIGINTERN void std_vector_Sl_int_Sg____delitem____SWIG_0(std::vector< int > *self,std::vector< int >::difference_type i){
swig::erase(self, swig::getpos(self, i));
}
SWIGINTERN std::vector< int,std::allocator< int > > *std_vector_Sl_int_Sg____getitem____SWIG_0(std::vector< int > *self,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return NULL;
}
PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< int,std::allocator< int > >::difference_type id = i;
std::vector< int,std::allocator< int > >::difference_type jd = j;
return swig::getslice(self, id, jd, step);
}
SWIGINTERN void std_vector_Sl_int_Sg____setitem____SWIG_0(std::vector< int > *self,PySliceObject *slice,std::vector< int,std::allocator< int > > const &v){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< int,std::allocator< int > >::difference_type id = i;
std::vector< int,std::allocator< int > >::difference_type jd = j;
swig::setslice(self, id, jd, step, v);
}
SWIGINTERN void std_vector_Sl_int_Sg____setitem____SWIG_1(std::vector< int > *self,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< int,std::allocator< int > >::difference_type id = i;
std::vector< int,std::allocator< int > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
}
SWIGINTERN void std_vector_Sl_int_Sg____delitem____SWIG_1(std::vector< int > *self,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< int,std::allocator< int > >::difference_type id = i;
std::vector< int,std::allocator< int > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
}
SWIGINTERN std::vector< int >::value_type const &std_vector_Sl_int_Sg____getitem____SWIG_1(std::vector< int > const *self,std::vector< int >::difference_type i){
return *(swig::cgetpos(self, i));
}
SWIGINTERN void std_vector_Sl_int_Sg____setitem____SWIG_2(std::vector< int > *self,std::vector< int >::difference_type i,std::vector< int >::value_type const &x){
*(swig::getpos(self,i)) = x;
}
SWIGINTERN std::vector< int >::value_type std_vector_Sl_int_Sg__pop(std::vector< int > *self){
if (self->size() == 0)
throw std::out_of_range("pop from empty container");
std::vector< int,std::allocator< int > >::value_type x = self->back();
self->pop_back();
return x;
}
SWIGINTERN void std_vector_Sl_int_Sg__append(std::vector< int > *self,std::vector< int >::value_type const &x){
self->push_back(x);
}
SWIGINTERN std::vector< int >::iterator std_vector_Sl_int_Sg__erase__SWIG_0(std::vector< int > *self,std::vector< int >::iterator pos){ return self->erase(pos); }
SWIGINTERN std::vector< int >::iterator std_vector_Sl_int_Sg__erase__SWIG_1(std::vector< int > *self,std::vector< int >::iterator first,std::vector< int >::iterator last){ return self->erase(first, last); }
SWIGINTERN std::vector< int >::iterator std_vector_Sl_int_Sg__insert__SWIG_0(std::vector< int > *self,std::vector< int >::iterator pos,std::vector< int >::value_type const &x){ return self->insert(pos, x); }
SWIGINTERN void std_vector_Sl_int_Sg__insert__SWIG_1(std::vector< int > *self,std::vector< int >::iterator pos,std::vector< int >::size_type n,std::vector< int >::value_type const &x){ self->insert(pos, n, x); }
SWIGINTERN cv::Matx< int,2,1 > *new_cv_Matx_Sl_int_Sc_2_Sc_1_Sg___SWIG_6(std::vector< cv::Matx< int,2,1 >::value_type,std::allocator< cv::Matx< int,2,1 >::value_type > > arg){
return Factory< cv::Matx< int,2,1 > >::construct(arg);
}
SWIGINTERN std::string cv_Matx_Sl_int_Sc_2_Sc_1_Sg____str__(cv::Matx< int,2,1 > *self){
std::ostringstream s;
s << *self;
return s.str();
}
SWIGINTERN cv::Vec< int,2 > *new_cv_Vec_Sl_int_Sc_2_Sg___SWIG_4(std::vector< cv::Vec< int,2 >::value_type,std::allocator< cv::Vec< int,2 >::value_type > > arg){
return Factory< cv::Vec< int,2 > >::construct(arg);
}
SWIGINTERN std::string cv_Vec_Sl_int_Sc_2_Sg____str__(cv::Vec< int,2 > *self){
std::ostringstream s;
s << *self;
return s.str();
}
SWIGINTERN cv::Matx< int,3,1 > *new_cv_Matx_Sl_int_Sc_3_Sc_1_Sg___SWIG_6(std::vector< cv::Matx< int,3,1 >::value_type,std::allocator< cv::Matx< int,3,1 >::value_type > > arg){
return Factory< cv::Matx< int,3,1 > >::construct(arg);
}
SWIGINTERN std::string cv_Matx_Sl_int_Sc_3_Sc_1_Sg____str__(cv::Matx< int,3,1 > *self){
std::ostringstream s;
s << *self;
return s.str();
}
SWIGINTERN cv::Vec< int,3 > *new_cv_Vec_Sl_int_Sc_3_Sg___SWIG_4(std::vector< cv::Vec< int,3 >::value_type,std::allocator< cv::Vec< int,3 >::value_type > > arg){
return Factory< cv::Vec< int,3 > >::construct(arg);
}
SWIGINTERN std::string cv_Vec_Sl_int_Sc_3_Sg____str__(cv::Vec< int,3 > *self){
std::ostringstream s;
s << *self;
return s.str();
}
SWIGINTERN cv::Matx< int,4,1 > *new_cv_Matx_Sl_int_Sc_4_Sc_1_Sg___SWIG_6(std::vector< cv::Matx< int,4,1 >::value_type,std::allocator< cv::Matx< int,4,1 >::value_type > > arg){
return Factory< cv::Matx< int,4,1 > >::construct(arg);
}
SWIGINTERN std::string cv_Matx_Sl_int_Sc_4_Sc_1_Sg____str__(cv::Matx< int,4,1 > *self){
std::ostringstream s;
s << *self;
return s.str();
}
SWIGINTERN cv::Vec< int,4 > *new_cv_Vec_Sl_int_Sc_4_Sg___SWIG_4(std::vector< cv::Vec< int,4 >::value_type,std::allocator< cv::Vec< int,4 >::value_type > > arg){
return Factory< cv::Vec< int,4 > >::construct(arg);
}
SWIGINTERN std::string cv_Vec_Sl_int_Sc_4_Sg____str__(cv::Vec< int,4 > *self){
std::ostringstream s;
s << *self;
return s.str();
}
SWIGINTERN cv::Matx< int,6,1 > *new_cv_Matx_Sl_int_Sc_6_Sc_1_Sg___SWIG_6(std::vector< cv::Matx< int,6,1 >::value_type,std::allocator< cv::Matx< int,6,1 >::value_type > > arg){
return Factory< cv::Matx< int,6,1 > >::construct(arg);
}
SWIGINTERN std::string cv_Matx_Sl_int_Sc_6_Sc_1_Sg____str__(cv::Matx< int,6,1 > *self){
std::ostringstream s;
s << *self;
return s.str();
}
SWIGINTERN cv::Vec< int,6 > *new_cv_Vec_Sl_int_Sc_6_Sg___SWIG_4(std::vector< cv::Vec< int,6 >::value_type,std::allocator< cv::Vec< int,6 >::value_type > > arg){
return Factory< cv::Vec< int,6 > >::construct(arg);
}
SWIGINTERN std::string cv_Vec_Sl_int_Sc_6_Sg____str__(cv::Vec< int,6 > *self){
std::ostringstream s;
s << *self;
return s.str();
}
SWIGINTERN cv::Matx< int,8,1 > *new_cv_Matx_Sl_int_Sc_8_Sc_1_Sg___SWIG_6(std::vector< cv::Matx< int,8,1 >::value_type,std::allocator< cv::Matx< int,8,1 >::value_type > > arg){
return Factory< cv::Matx< int,8,1 > >::construct(arg);
}
SWIGINTERN std::string cv_Matx_Sl_int_Sc_8_Sc_1_Sg____str__(cv::Matx< int,8,1 > *self){
std::ostringstream s;
s << *self;
return s.str();
}
SWIGINTERN cv::Vec< int,8 > *new_cv_Vec_Sl_int_Sc_8_Sg___SWIG_4(std::vector< cv::Vec< int,8 >::value_type,std::allocator< cv::Vec< int,8 >::value_type > > arg){
return Factory< cv::Vec< int,8 > >::construct(arg);
}
SWIGINTERN std::string cv_Vec_Sl_int_Sc_8_Sg____str__(cv::Vec< int,8 > *self){
std::ostringstream s;
s << *self;
return s.str();
}
/* Getting isfinite working pre C99 across multiple platforms is non-trivial. Users can provide SWIG_isfinite on older platforms. */
#ifndef SWIG_isfinite
# if defined(isfinite)
# define SWIG_isfinite(X) (isfinite(X))
# elif defined(_MSC_VER)
# define SWIG_isfinite(X) (_finite(X))
# elif defined(__sun) && defined(__SVR4)
# include <ieeefp.h>
# define SWIG_isfinite(X) (finite(X))
# endif
#endif
/* Accept infinite as a valid float value unless we are unable to check if a value is finite */
#ifdef SWIG_isfinite
# define SWIG_Float_Overflow_Check(X) ((X < -FLT_MAX || X > FLT_MAX) && SWIG_isfinite(X))
#else
# define SWIG_Float_Overflow_Check(X) ((X < -FLT_MAX || X > FLT_MAX))
#endif
SWIGINTERN int
SWIG_AsVal_float (PyObject * obj, float *val)
{
double v;
int res = SWIG_AsVal_double (obj, &v);
if (SWIG_IsOK(res)) {
if (SWIG_Float_Overflow_Check(v)) {
return SWIG_OverflowError;
} else {
if (val) *val = static_cast< float >(v);
}
}
return res;
}
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 <> 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::SwigPyIterator *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 bool std_vector_Sl_float_Sg____bool__(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();
}
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, 1);
}
SWIGINTERN void std_vector_Sl_float_Sg____setslice____SWIG_0(std::vector< float > *self,std::vector< float >::difference_type i,std::vector< float >::difference_type j){
swig::setslice(self, i, j, 1, std::vector< float,std::allocator< float > >());
}
SWIGINTERN void std_vector_Sl_float_Sg____setslice____SWIG_1(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, 1, 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, 1);
}
SWIGINTERN void std_vector_Sl_float_Sg____delitem____SWIG_0(std::vector< float > *self,std::vector< float >::difference_type i){
swig::erase(self, swig::getpos(self, i));
}
SWIGINTERN std::vector< float,std::allocator< float > > *std_vector_Sl_float_Sg____getitem____SWIG_0(std::vector< float > *self,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return NULL;
}
PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< float,std::allocator< float > >::difference_type id = i;
std::vector< float,std::allocator< float > >::difference_type jd = j;
return swig::getslice(self, id, jd, step);
}
SWIGINTERN void std_vector_Sl_float_Sg____setitem____SWIG_0(std::vector< float > *self,PySliceObject *slice,std::vector< float,std::allocator< float > > const &v){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< float,std::allocator< float > >::difference_type id = i;
std::vector< float,std::allocator< float > >::difference_type jd = j;
swig::setslice(self, id, jd, step, v);
}
SWIGINTERN void std_vector_Sl_float_Sg____setitem____SWIG_1(std::vector< float > *self,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< float,std::allocator< float > >::difference_type id = i;
std::vector< float,std::allocator< float > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
}
SWIGINTERN void std_vector_Sl_float_Sg____delitem____SWIG_1(std::vector< float > *self,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< float,std::allocator< float > >::difference_type id = i;
std::vector< float,std::allocator< float > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
}
SWIGINTERN std::vector< float >::value_type const &std_vector_Sl_float_Sg____getitem____SWIG_1(std::vector< float > const *self,std::vector< float >::difference_type i){
return *(swig::cgetpos(self, i));
}
SWIGINTERN void std_vector_Sl_float_Sg____setitem____SWIG_2(std::vector< float > *self,std::vector< float >::difference_type i,std::vector< float >::value_type const &x){
*(swig::getpos(self,i)) = x;
}
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 void std_vector_Sl_float_Sg__append(std::vector< float > *self,std::vector< float >::value_type const &x){
self->push_back(x);
}
SWIGINTERN std::vector< float >::iterator std_vector_Sl_float_Sg__erase__SWIG_0(std::vector< float > *self,std::vector< float >::iterator pos){ return self->erase(pos); }
SWIGINTERN std::vector< float >::iterator std_vector_Sl_float_Sg__erase__SWIG_1(std::vector< float > *self,std::vector< float >::iterator first,std::vector< float >::iterator last){ return self->erase(first, last); }
SWIGINTERN std::vector< float >::iterator std_vector_Sl_float_Sg__insert__SWIG_0(std::vector< float > *self,std::vector< float >::iterator pos,std::vector< float >::value_type const &x){ return self->insert(pos, x); }
SWIGINTERN void std_vector_Sl_float_Sg__insert__SWIG_1(std::vector< float > *self,std::vector< float >::iterator pos,std::vector< float >::size_type n,std::vector< float >::value_type const &x){ self->insert(pos, n, x); }
SWIGINTERN cv::Matx< float,2,1 > *new_cv_Matx_Sl_float_Sc_2_Sc_1_Sg___SWIG_6(std::vector< cv::Matx< float,2,1 >::value_type,std::allocator< cv::Matx< float,2,1 >::value_type > > arg){
return Factory< cv::Matx< float,2,1 > >::construct(arg);
}
SWIGINTERN std::string cv_Matx_Sl_float_Sc_2_Sc_1_Sg____str__(cv::Matx< float,2,1 > *self){
std::ostringstream s;
s << *self;
return s.str();
}
SWIGINTERN cv::Vec< float,2 > *new_cv_Vec_Sl_float_Sc_2_Sg___SWIG_4(std::vector< cv::Vec< float,2 >::value_type,std::allocator< cv::Vec< float,2 >::value_type > > arg){
return Factory< cv::Vec< float,2 > >::construct(arg);
}
SWIGINTERN std::string cv_Vec_Sl_float_Sc_2_Sg____str__(cv::Vec< float,2 > *self){
std::ostringstream s;
s << *self;
return s.str();
}
SWIGINTERN cv::Matx< float,3,1 > *new_cv_Matx_Sl_float_Sc_3_Sc_1_Sg___SWIG_6(std::vector< cv::Matx< float,3,1 >::value_type,std::allocator< cv::Matx< float,3,1 >::value_type > > arg){
return Factory< cv::Matx< float,3,1 > >::construct(arg);
}
SWIGINTERN std::string cv_Matx_Sl_float_Sc_3_Sc_1_Sg____str__(cv::Matx< float,3,1 > *self){
std::ostringstream s;
s << *self;
return s.str();
}
SWIGINTERN cv::Vec< float,3 > *new_cv_Vec_Sl_float_Sc_3_Sg___SWIG_4(std::vector< cv::Vec< float,3 >::value_type,std::allocator< cv::Vec< float,3 >::value_type > > arg){
return Factory< cv::Vec< float,3 > >::construct(arg);
}
SWIGINTERN std::string cv_Vec_Sl_float_Sc_3_Sg____str__(cv::Vec< float,3 > *self){
std::ostringstream s;
s << *self;
return s.str();
}
SWIGINTERN cv::Matx< float,4,1 > *new_cv_Matx_Sl_float_Sc_4_Sc_1_Sg___SWIG_6(std::vector< cv::Matx< float,4,1 >::value_type,std::allocator< cv::Matx< float,4,1 >::value_type > > arg){
return Factory< cv::Matx< float,4,1 > >::construct(arg);
}
SWIGINTERN std::string cv_Matx_Sl_float_Sc_4_Sc_1_Sg____str__(cv::Matx< float,4,1 > *self){
std::ostringstream s;
s << *self;
return s.str();
}
SWIGINTERN cv::Vec< float,4 > *new_cv_Vec_Sl_float_Sc_4_Sg___SWIG_4(std::vector< cv::Vec< float,4 >::value_type,std::allocator< cv::Vec< float,4 >::value_type > > arg){
return Factory< cv::Vec< float,4 > >::construct(arg);
}
SWIGINTERN std::string cv_Vec_Sl_float_Sc_4_Sg____str__(cv::Vec< float,4 > *self){
std::ostringstream s;
s << *self;
return s.str();
}
SWIGINTERN cv::Matx< float,6,1 > *new_cv_Matx_Sl_float_Sc_6_Sc_1_Sg___SWIG_6(std::vector< cv::Matx< float,6,1 >::value_type,std::allocator< cv::Matx< float,6,1 >::value_type > > arg){
return Factory< cv::Matx< float,6,1 > >::construct(arg);
}
SWIGINTERN std::string cv_Matx_Sl_float_Sc_6_Sc_1_Sg____str__(cv::Matx< float,6,1 > *self){
std::ostringstream s;
s << *self;
return s.str();
}
SWIGINTERN cv::Vec< float,6 > *new_cv_Vec_Sl_float_Sc_6_Sg___SWIG_4(std::vector< cv::Vec< float,6 >::value_type,std::allocator< cv::Vec< float,6 >::value_type > > arg){
return Factory< cv::Vec< float,6 > >::construct(arg);
}
SWIGINTERN std::string cv_Vec_Sl_float_Sc_6_Sg____str__(cv::Vec< float,6 > *self){
std::ostringstream s;
s << *self;
return s.str();
}
namespace swig {
template <> struct traits< double > {
typedef value_category category;
static const char* type_name() { return"double"; }
};
template <> struct traits_asval< double > {
typedef double value_type;
static int asval(PyObject *obj, value_type *val) {
return SWIG_AsVal_double (obj, val);
}
};
template <> struct traits_from< double > {
typedef double value_type;
static PyObject *from(const value_type& val) {
return SWIG_From_double (val);
}
};
}
namespace swig {
template <> struct traits<std::vector< double, std::allocator< double > > > {
typedef pointer_category category;
static const char* type_name() {
return "std::vector<" "double" "," "std::allocator< double >" " >";
}
};
}
SWIGINTERN swig::SwigPyIterator *std_vector_Sl_double_Sg__iterator(std::vector< double > *self,PyObject **PYTHON_SELF){
return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
}
SWIGINTERN bool std_vector_Sl_double_Sg____nonzero__(std::vector< double > const *self){
return !(self->empty());
}
SWIGINTERN bool std_vector_Sl_double_Sg____bool__(std::vector< double > const *self){
return !(self->empty());
}
SWIGINTERN std::vector< double >::size_type std_vector_Sl_double_Sg____len__(std::vector< double > const *self){
return self->size();
}
SWIGINTERN std::vector< double,std::allocator< double > > *std_vector_Sl_double_Sg____getslice__(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j){
return swig::getslice(self, i, j, 1);
}
SWIGINTERN void std_vector_Sl_double_Sg____setslice____SWIG_0(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j){
swig::setslice(self, i, j, 1, std::vector< double,std::allocator< double > >());
}
SWIGINTERN void std_vector_Sl_double_Sg____setslice____SWIG_1(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j,std::vector< double,std::allocator< double > > const &v){
swig::setslice(self, i, j, 1, v);
}
SWIGINTERN void std_vector_Sl_double_Sg____delslice__(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j){
swig::delslice(self, i, j, 1);
}
SWIGINTERN void std_vector_Sl_double_Sg____delitem____SWIG_0(std::vector< double > *self,std::vector< double >::difference_type i){
swig::erase(self, swig::getpos(self, i));
}
SWIGINTERN std::vector< double,std::allocator< double > > *std_vector_Sl_double_Sg____getitem____SWIG_0(std::vector< double > *self,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return NULL;
}
PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< double,std::allocator< double > >::difference_type id = i;
std::vector< double,std::allocator< double > >::difference_type jd = j;
return swig::getslice(self, id, jd, step);
}
SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_0(std::vector< double > *self,PySliceObject *slice,std::vector< double,std::allocator< double > > const &v){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< double,std::allocator< double > >::difference_type id = i;
std::vector< double,std::allocator< double > >::difference_type jd = j;
swig::setslice(self, id, jd, step, v);
}
SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_1(std::vector< double > *self,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< double,std::allocator< double > >::difference_type id = i;
std::vector< double,std::allocator< double > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
}
SWIGINTERN void std_vector_Sl_double_Sg____delitem____SWIG_1(std::vector< double > *self,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< double,std::allocator< double > >::difference_type id = i;
std::vector< double,std::allocator< double > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
}
SWIGINTERN std::vector< double >::value_type const &std_vector_Sl_double_Sg____getitem____SWIG_1(std::vector< double > const *self,std::vector< double >::difference_type i){
return *(swig::cgetpos(self, i));
}
SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_2(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::value_type const &x){
*(swig::getpos(self,i)) = x;
}
SWIGINTERN std::vector< double >::value_type std_vector_Sl_double_Sg__pop(std::vector< double > *self){
if (self->size() == 0)
throw std::out_of_range("pop from empty container");
std::vector< double,std::allocator< double > >::value_type x = self->back();
self->pop_back();
return x;
}
SWIGINTERN void std_vector_Sl_double_Sg__append(std::vector< double > *self,std::vector< double >::value_type const &x){
self->push_back(x);
}
SWIGINTERN std::vector< double >::iterator std_vector_Sl_double_Sg__erase__SWIG_0(std::vector< double > *self,std::vector< double >::iterator pos){ return self->erase(pos); }
SWIGINTERN std::vector< double >::iterator std_vector_Sl_double_Sg__erase__SWIG_1(std::vector< double > *self,std::vector< double >::iterator first,std::vector< double >::iterator last){ return self->erase(first, last); }
SWIGINTERN std::vector< double >::iterator std_vector_Sl_double_Sg__insert__SWIG_0(std::vector< double > *self,std::vector< double >::iterator pos,std::vector< double >::value_type const &x){ return self->insert(pos, x); }
SWIGINTERN void std_vector_Sl_double_Sg__insert__SWIG_1(std::vector< double > *self,std::vector< double >::iterator pos,std::vector< double >::size_type n,std::vector< double >::value_type const &x){ self->insert(pos, n, x); }
SWIGINTERN cv::Matx< double,2,1 > *new_cv_Matx_Sl_double_Sc_2_Sc_1_Sg___SWIG_6(std::vector< cv::Matx< double,2,1 >::value_type,std::allocator< cv::Matx< double,2,1 >::value_type > > arg){
return Factory< cv::Matx< double,2,1 > >::construct(arg);
}
SWIGINTERN std::string cv_Matx_Sl_double_Sc_2_Sc_1_Sg____str__(cv::Matx< double,2,1 > *self){
std::ostringstream s;
s << *self;
return s.str();
}
SWIGINTERN cv::Vec< double,2 > *new_cv_Vec_Sl_double_Sc_2_Sg___SWIG_4(std::vector< cv::Vec< double,2 >::value_type,std::allocator< cv::Vec< double,2 >::value_type > > arg){
return Factory< cv::Vec< double,2 > >::construct(arg);
}
SWIGINTERN std::string cv_Vec_Sl_double_Sc_2_Sg____str__(cv::Vec< double,2 > *self){
std::ostringstream s;
s << *self;
return s.str();
}
SWIGINTERN cv::Matx< double,3,1 > *new_cv_Matx_Sl_double_Sc_3_Sc_1_Sg___SWIG_6(std::vector< cv::Matx< double,3,1 >::value_type,std::allocator< cv::Matx< double,3,1 >::value_type > > arg){
return Factory< cv::Matx< double,3,1 > >::construct(arg);
}
SWIGINTERN std::string cv_Matx_Sl_double_Sc_3_Sc_1_Sg____str__(cv::Matx< double,3,1 > *self){
std::ostringstream s;
s << *self;
return s.str();
}
SWIGINTERN cv::Vec< double,3 > *new_cv_Vec_Sl_double_Sc_3_Sg___SWIG_4(std::vector< cv::Vec< double,3 >::value_type,std::allocator< cv::Vec< double,3 >::value_type > > arg){
return Factory< cv::Vec< double,3 > >::construct(arg);
}
SWIGINTERN std::string cv_Vec_Sl_double_Sc_3_Sg____str__(cv::Vec< double,3 > *self){
std::ostringstream s;
s << *self;
return s.str();
}
SWIGINTERN cv::Matx< double,4,1 > *new_cv_Matx_Sl_double_Sc_4_Sc_1_Sg___SWIG_6(std::vector< cv::Matx< double,4,1 >::value_type,std::allocator< cv::Matx< double,4,1 >::value_type > > arg){
return Factory< cv::Matx< double,4,1 > >::construct(arg);
}
SWIGINTERN std::string cv_Matx_Sl_double_Sc_4_Sc_1_Sg____str__(cv::Matx< double,4,1 > *self){
std::ostringstream s;
s << *self;
return s.str();
}
SWIGINTERN cv::Vec< double,4 > *new_cv_Vec_Sl_double_Sc_4_Sg___SWIG_4(std::vector< cv::Vec< double,4 >::value_type,std::allocator< cv::Vec< double,4 >::value_type > > arg){
return Factory< cv::Vec< double,4 > >::construct(arg);
}
SWIGINTERN std::string cv_Vec_Sl_double_Sc_4_Sg____str__(cv::Vec< double,4 > *self){
std::ostringstream s;
s << *self;
return s.str();
}
SWIGINTERN cv::Matx< double,6,1 > *new_cv_Matx_Sl_double_Sc_6_Sc_1_Sg___SWIG_6(std::vector< cv::Matx< double,6,1 >::value_type,std::allocator< cv::Matx< double,6,1 >::value_type > > arg){
return Factory< cv::Matx< double,6,1 > >::construct(arg);
}
SWIGINTERN std::string cv_Matx_Sl_double_Sc_6_Sc_1_Sg____str__(cv::Matx< double,6,1 > *self){
std::ostringstream s;
s << *self;
return s.str();
}
SWIGINTERN cv::Vec< double,6 > *new_cv_Vec_Sl_double_Sc_6_Sg___SWIG_4(std::vector< cv::Vec< double,6 >::value_type,std::allocator< cv::Vec< double,6 >::value_type > > arg){
return Factory< cv::Vec< double,6 > >::construct(arg);
}
SWIGINTERN std::string cv_Vec_Sl_double_Sc_6_Sg____str__(cv::Vec< double,6 > *self){
std::ostringstream s;
s << *self;
return s.str();
}
#include <opencv2/core/core.hpp>
#include <sstream>
struct _mat__np_array_constructor
{};
char const* _depthToDtype(int depth)
{
switch(depth)
{
case CV_8U:
return "u1";
case CV_8S:
return "i1";
case CV_16U:
return "u2";
case CV_16S:
return "i2";
case CV_32S:
return "i4";
case CV_32F:
return "f4";
case CV_64F:
return "f8";
}
return NULL;
}
int _toCvType(std::string const& dtype, int nChannel)
{
int depth;
if (dtype == "u1")
{
depth = CV_8U;
}
else if (dtype == "i1")
{
depth = CV_8S;
}
else if (dtype == "u2")
{
depth = CV_16U;
}
else if (dtype == "i2")
{
depth = CV_16S;
}
else if (dtype == "i4")
{
depth = CV_32S;
}
else if (dtype == "f4")
{
depth = CV_32F;
}
else if (dtype == "f8")
{
depth = CV_64F;
}
return CV_MAKETYPE(depth, nChannel);
}
SWIGINTERN int
SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
{
#if PY_VERSION_HEX>=0x03000000
if (PyUnicode_Check(obj))
#else
if (PyString_Check(obj))
#endif
{
char *cstr; Py_ssize_t len;
#if PY_VERSION_HEX>=0x03000000
if (!alloc && cptr) {
/* We can't allow converting without allocation, since the internal
representation of string in Python 3 is UCS-2/UCS-4 but we require
a UTF-8 representation.
TODO(bhy) More detailed explanation */
return SWIG_RuntimeError;
}
obj = PyUnicode_AsUTF8String(obj);
PyBytes_AsStringAndSize(obj, &cstr, &len);
if(alloc) *alloc = SWIG_NEWOBJ;
#else
PyString_AsStringAndSize(obj, &cstr, &len);
#endif
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 {
#if PY_VERSION_HEX>=0x03000000
assert(0); /* Should never reach here in Python 3 */
#endif
*cptr = SWIG_Python_str_AsChar(obj);
}
}
if (psize) *psize = len + 1;
#if PY_VERSION_HEX>=0x03000000
Py_XDECREF(obj);
#endif
return SWIG_OK;
} else {
#if defined(SWIG_PYTHON_2_UNICODE)
#if PY_VERSION_HEX<0x03000000
if (PyUnicode_Check(obj)) {
char *cstr; Py_ssize_t len;
if (!alloc && cptr) {
return SWIG_RuntimeError;
}
obj = PyUnicode_AsUTF8String(obj);
if (PyString_AsStringAndSize(obj, &cstr, &len) != -1) {
if (cptr) {
if (alloc) *alloc = SWIG_NEWOBJ;
*cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
}
if (psize) *psize = len + 1;
Py_XDECREF(obj);
return SWIG_OK;
} else {
Py_XDECREF(obj);
}
}
#endif
#endif
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;
}
SWIGINTERN int
SWIG_AsPtr_std_string (PyObject * obj, std::string **val)
{
char* buf = 0 ; size_t size = 0; int alloc = SWIG_OLDOBJ;
if (SWIG_IsOK((SWIG_AsCharPtrAndSize(obj, &buf, &size, &alloc)))) {
if (buf) {
if (val) *val = new std::string(buf, size - 1);
if (alloc == SWIG_NEWOBJ) delete[] buf;
return SWIG_NEWOBJ;
} else {
if (val) *val = 0;
return SWIG_OLDOBJ;
}
} else {
static int init = 0;
static swig_type_info* descriptor = 0;
if (!init) {
descriptor = SWIG_TypeQuery("std::string" " *");
init = 1;
}
if (descriptor) {
std::string *vptr;
int res = SWIG_ConvertPtr(obj, (void**)&vptr, descriptor, 0);
if (SWIG_IsOK(res) && val) *val = vptr;
return res;
}
}
return SWIG_ERROR;
}
#include "tracker.h"
#include "kcftracker.hpp"
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)) {
/* special case of single char conversion when we don't need space for NUL */
if (size == 1 && csize == 2 && cptr && !cptr[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;
}
size_t
SWIG_strnlen(const char* s, size_t maxlen)
{
const char *p;
for (p = s; maxlen-- && *p; p++)
;
return p - s;
}
SWIGINTERN int
SWIG_AsVal_unsigned_SS_short (PyObject * obj, unsigned short *val)
{
unsigned long v;
int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
if (SWIG_IsOK(res)) {
if ((v > USHRT_MAX)) {
return SWIG_OverflowError;
} else {
if (val) *val = static_cast< unsigned short >(v);
}
}
return res;
}
SWIGINTERNINLINE PyObject *
SWIG_From_unsigned_SS_short (unsigned short value)
{
return SWIG_From_unsigned_SS_long (value);
}
#ifdef __cplusplus
extern "C" {
#endif
SWIGINTERN PyObject *CV_VERSION_MAJOR_swigconstant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *module;
PyObject *d;
if (!PyArg_ParseTuple(args,(char*)"O:swigconstant", &module)) return NULL;
d = PyModule_GetDict(module);
if (!d) return NULL;
SWIG_Python_SetConstant(d, "CV_VERSION_MAJOR",SWIG_From_int(static_cast< int >(3)));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *CV_VERSION_MINOR_swigconstant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *module;
PyObject *d;
if (!PyArg_ParseTuple(args,(char*)"O:swigconstant", &module)) return NULL;
d = PyModule_GetDict(module);
if (!d) return NULL;
SWIG_Python_SetConstant(d, "CV_VERSION_MINOR",SWIG_From_int(static_cast< int >(4)));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *CV_VERSION_REVISION_swigconstant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *module;
PyObject *d;
if (!PyArg_ParseTuple(args,(char*)"O:swigconstant", &module)) return NULL;
d = PyModule_GetDict(module);
if (!d) return NULL;
SWIG_Python_SetConstant(d, "CV_VERSION_REVISION",SWIG_From_int(static_cast< int >(4)));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *CV_VERSION_STATUS_swigconstant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *module;
PyObject *d;
if (!PyArg_ParseTuple(args,(char*)"O:swigconstant", &module)) return NULL;
d = PyModule_GetDict(module);
if (!d) return NULL;
SWIG_Python_SetConstant(d, "CV_VERSION_STATUS",SWIG_FromCharPtr("-dev"));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *CV_VERSION_swigconstant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *module;
PyObject *d;
if (!PyArg_ParseTuple(args,(char*)"O:swigconstant", &module)) return NULL;
d = PyModule_GetDict(module);
if (!d) return NULL;
SWIG_Python_SetConstant(d, "CV_VERSION",SWIG_FromCharPtr("3.4.4-dev"));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *CV_MAJOR_VERSION_swigconstant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *module;
PyObject *d;
if (!PyArg_ParseTuple(args,(char*)"O:swigconstant", &module)) return NULL;
d = PyModule_GetDict(module);
if (!d) return NULL;
SWIG_Python_SetConstant(d, "CV_MAJOR_VERSION",SWIG_From_int(static_cast< int >(3)));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *CV_MINOR_VERSION_swigconstant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *module;
PyObject *d;
if (!PyArg_ParseTuple(args,(char*)"O:swigconstant", &module)) return NULL;
d = PyModule_GetDict(module);
if (!d) return NULL;
SWIG_Python_SetConstant(d, "CV_MINOR_VERSION",SWIG_From_int(static_cast< int >(4)));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *CV_SUBMINOR_VERSION_swigconstant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *module;
PyObject *d;
if (!PyArg_ParseTuple(args,(char*)"O:swigconstant", &module)) return NULL;
d = PyModule_GetDict(module);
if (!d) return NULL;
SWIG_Python_SetConstant(d, "CV_SUBMINOR_VERSION",SWIG_From_int(static_cast< int >(4)));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_new_DataType_bool(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::DataType< bool > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new_DataType_bool")) SWIG_fail;
result = (cv::DataType< bool > *)new cv::DataType< bool >();
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__DataTypeT_bool_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_DataType_bool(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::DataType< bool > *arg1 = (cv::DataType< bool > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_DataType_bool",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__DataTypeT_bool_t, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DataType_bool" "', argument " "1"" of type '" "cv::DataType< bool > *""'");
}
arg1 = reinterpret_cast< cv::DataType< bool > * >(argp1);
delete arg1;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *DataType_bool_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_cv__DataTypeT_bool_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_new_DataType_uchar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::DataType< uchar > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new_DataType_uchar")) SWIG_fail;
result = (cv::DataType< uchar > *)new cv::DataType< uchar >();
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__DataTypeT_uchar_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_DataType_uchar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::DataType< uchar > *arg1 = (cv::DataType< uchar > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_DataType_uchar",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__DataTypeT_uchar_t, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DataType_uchar" "', argument " "1"" of type '" "cv::DataType< uchar > *""'");
}
arg1 = reinterpret_cast< cv::DataType< uchar > * >(argp1);
delete arg1;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *DataType_uchar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_cv__DataTypeT_uchar_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_new_DataType_schar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::DataType< schar > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new_DataType_schar")) SWIG_fail;
result = (cv::DataType< schar > *)new cv::DataType< schar >();
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__DataTypeT_schar_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_DataType_schar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::DataType< schar > *arg1 = (cv::DataType< schar > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_DataType_schar",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__DataTypeT_schar_t, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DataType_schar" "', argument " "1"" of type '" "cv::DataType< schar > *""'");
}
arg1 = reinterpret_cast< cv::DataType< schar > * >(argp1);
delete arg1;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *DataType_schar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_cv__DataTypeT_schar_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_new_DataType_char(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::DataType< char > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new_DataType_char")) SWIG_fail;
result = (cv::DataType< char > *)new cv::DataType< char >();
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__DataTypeT_char_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_DataType_char(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::DataType< char > *arg1 = (cv::DataType< char > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_DataType_char",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__DataTypeT_char_t, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DataType_char" "', argument " "1"" of type '" "cv::DataType< char > *""'");
}
arg1 = reinterpret_cast< cv::DataType< char > * >(argp1);
delete arg1;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *DataType_char_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_cv__DataTypeT_char_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_new_DataType_ushort(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::DataType< ushort > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new_DataType_ushort")) SWIG_fail;
result = (cv::DataType< ushort > *)new cv::DataType< ushort >();
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__DataTypeT_ushort_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_DataType_ushort(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::DataType< ushort > *arg1 = (cv::DataType< ushort > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_DataType_ushort",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__DataTypeT_ushort_t, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DataType_ushort" "', argument " "1"" of type '" "cv::DataType< ushort > *""'");
}
arg1 = reinterpret_cast< cv::DataType< ushort > * >(argp1);
delete arg1;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *DataType_ushort_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_cv__DataTypeT_ushort_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_new_DataType_short(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::DataType< short > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new_DataType_short")) SWIG_fail;
result = (cv::DataType< short > *)new cv::DataType< short >();
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__DataTypeT_short_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_DataType_short(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::DataType< short > *arg1 = (cv::DataType< short > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_DataType_short",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__DataTypeT_short_t, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DataType_short" "', argument " "1"" of type '" "cv::DataType< short > *""'");
}
arg1 = reinterpret_cast< cv::DataType< short > * >(argp1);
delete arg1;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *DataType_short_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_cv__DataTypeT_short_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_new_DataType_int(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::DataType< int > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new_DataType_int")) SWIG_fail;
result = (cv::DataType< int > *)new cv::DataType< int >();
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__DataTypeT_int_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_DataType_int(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::DataType< int > *arg1 = (cv::DataType< int > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_DataType_int",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__DataTypeT_int_t, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DataType_int" "', argument " "1"" of type '" "cv::DataType< int > *""'");
}
arg1 = reinterpret_cast< cv::DataType< int > * >(argp1);
delete arg1;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *DataType_int_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_cv__DataTypeT_int_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_new_DataType_float(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::DataType< float > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new_DataType_float")) SWIG_fail;
result = (cv::DataType< float > *)new cv::DataType< float >();
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__DataTypeT_float_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_DataType_float(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::DataType< float > *arg1 = (cv::DataType< float > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_DataType_float",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__DataTypeT_float_t, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DataType_float" "', argument " "1"" of type '" "cv::DataType< float > *""'");
}
arg1 = reinterpret_cast< cv::DataType< float > * >(argp1);
delete arg1;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *DataType_float_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_cv__DataTypeT_float_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_new_DataType_double(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::DataType< double > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new_DataType_double")) SWIG_fail;
result = (cv::DataType< double > *)new cv::DataType< double >();
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__DataTypeT_double_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_DataType_double(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::DataType< double > *arg1 = (cv::DataType< double > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_DataType_double",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__DataTypeT_double_t, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DataType_double" "', argument " "1"" of type '" "cv::DataType< double > *""'");
}
arg1 = reinterpret_cast< cv::DataType< double > * >(argp1);
delete arg1;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *DataType_double_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_cv__DataTypeT_double_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_new_Range__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Range *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new_Range")) SWIG_fail;
result = (cv::Range *)new cv::Range();
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__Range, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_Range__SWIG_1(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 ;
cv::Range *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:new_Range",&obj0,&obj1)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Range" "', 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_Range" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
result = (cv::Range *)new cv::Range(arg1,arg2);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__Range, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_Range(PyObject *self, PyObject *args) {
Py_ssize_t argc;
PyObject *argv[3] = {
0
};
Py_ssize_t ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = args ? PyObject_Length(args) : 0;
for (ii = 0; (ii < 2) && (ii < argc); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 0) {
return _wrap_new_Range__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_Range__SWIG_1(self, args);
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Range'.\n"
" Possible C/C++ prototypes are:\n"
" cv::Range::Range()\n"
" cv::Range::Range(int,int)\n");
return 0;
}
SWIGINTERN PyObject *_wrap_Range_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Range *arg1 = (cv::Range *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:Range_size",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__Range, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Range_size" "', argument " "1"" of type '" "cv::Range const *""'");
}
arg1 = reinterpret_cast< cv::Range * >(argp1);
result = (int)((cv::Range const *)arg1)->size();
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Range_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Range *arg1 = (cv::Range *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
bool result;
if (!PyArg_ParseTuple(args,(char *)"O:Range_empty",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__Range, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Range_empty" "', argument " "1"" of type '" "cv::Range const *""'");
}
arg1 = reinterpret_cast< cv::Range * >(argp1);
result = (bool)((cv::Range const *)arg1)->empty();
resultobj = SWIG_From_bool(static_cast< bool >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Range_all(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Range result;
if (!PyArg_ParseTuple(args,(char *)":Range_all")) SWIG_fail;
result = cv::Range::all();
resultobj = SWIG_NewPointerObj((new cv::Range(static_cast< const cv::Range& >(result))), SWIGTYPE_p_cv__Range, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Range_start_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Range *arg1 = (cv::Range *) 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:Range_start_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__Range, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Range_start_set" "', argument " "1"" of type '" "cv::Range *""'");
}
arg1 = reinterpret_cast< cv::Range * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Range_start_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->start = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Range_start_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Range *arg1 = (cv::Range *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:Range_start_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__Range, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Range_start_get" "', argument " "1"" of type '" "cv::Range *""'");
}
arg1 = reinterpret_cast< cv::Range * >(argp1);
result = (int) ((arg1)->start);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Range_end_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Range *arg1 = (cv::Range *) 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:Range_end_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__Range, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Range_end_set" "', argument " "1"" of type '" "cv::Range *""'");
}
arg1 = reinterpret_cast< cv::Range * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Range_end_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->end = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Range_end_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Range *arg1 = (cv::Range *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:Range_end_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__Range, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Range_end_get" "', argument " "1"" of type '" "cv::Range *""'");
}
arg1 = reinterpret_cast< cv::Range * >(argp1);
result = (int) ((arg1)->end);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_Range(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Range *arg1 = (cv::Range *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_Range",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__Range, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Range" "', argument " "1"" of type '" "cv::Range *""'");
}
arg1 = reinterpret_cast< cv::Range * >(argp1);
delete arg1;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *Range_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_cv__Range, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_delete_SwigPyIterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_SwigPyIterator",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SwigPyIterator" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
}
arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
delete arg1;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_SwigPyIterator_value(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
PyObject *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:SwigPyIterator_value",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_value" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
}
arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
try {
result = (PyObject *)((swig::SwigPyIterator 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_SwigPyIterator_incr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
size_t arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
size_t val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
swig::SwigPyIterator *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator_incr",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_incr" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
}
arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
ecode2 = SWIG_AsVal_size_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator_incr" "', argument " "2"" of type '" "size_t""'");
}
arg2 = static_cast< size_t >(val2);
try {
result = (swig::SwigPyIterator *)(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__SwigPyIterator, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_SwigPyIterator_incr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
swig::SwigPyIterator *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:SwigPyIterator_incr",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_incr" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
}
arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
try {
result = (swig::SwigPyIterator *)(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__SwigPyIterator, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_SwigPyIterator_incr(PyObject *self, PyObject *args) {
Py_ssize_t argc;
PyObject *argv[3] = {
0
};
Py_ssize_t ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = args ? PyObject_Length(args) : 0;
for (ii = 0; (ii < 2) && (ii < argc); 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__SwigPyIterator, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_SwigPyIterator_incr__SWIG_1(self, args);
}
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_size_t(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_SwigPyIterator_incr__SWIG_0(self, args);
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SwigPyIterator_incr'.\n"
" Possible C/C++ prototypes are:\n"
" swig::SwigPyIterator::incr(size_t)\n"
" swig::SwigPyIterator::incr()\n");
return 0;
}
SWIGINTERN PyObject *_wrap_SwigPyIterator_decr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
size_t arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
size_t val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
swig::SwigPyIterator *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator_decr",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_decr" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
}
arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
ecode2 = SWIG_AsVal_size_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator_decr" "', argument " "2"" of type '" "size_t""'");
}
arg2 = static_cast< size_t >(val2);
try {
result = (swig::SwigPyIterator *)(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__SwigPyIterator, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_SwigPyIterator_decr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
swig::SwigPyIterator *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:SwigPyIterator_decr",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_decr" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
}
arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
try {
result = (swig::SwigPyIterator *)(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__SwigPyIterator, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_SwigPyIterator_decr(PyObject *self, PyObject *args) {
Py_ssize_t argc;
PyObject *argv[3] = {
0
};
Py_ssize_t ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = args ? PyObject_Length(args) : 0;
for (ii = 0; (ii < 2) && (ii < argc); 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__SwigPyIterator, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_SwigPyIterator_decr__SWIG_1(self, args);
}
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_size_t(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_SwigPyIterator_decr__SWIG_0(self, args);
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SwigPyIterator_decr'.\n"
" Possible C/C++ prototypes are:\n"
" swig::SwigPyIterator::decr(size_t)\n"
" swig::SwigPyIterator::decr()\n");
return 0;
}
SWIGINTERN PyObject *_wrap_SwigPyIterator_distance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
swig::SwigPyIterator *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:SwigPyIterator_distance",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_distance" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
}
arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator_distance" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator_distance" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
}
arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
try {
result = ((swig::SwigPyIterator const *)arg1)->distance((swig::SwigPyIterator 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_SwigPyIterator_equal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
swig::SwigPyIterator *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:SwigPyIterator_equal",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_equal" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
}
arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator_equal" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator_equal" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
}
arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
try {
result = (bool)((swig::SwigPyIterator const *)arg1)->equal((swig::SwigPyIterator 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_SwigPyIterator_copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
swig::SwigPyIterator *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:SwigPyIterator_copy",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_copy" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
}
arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
result = (swig::SwigPyIterator *)((swig::SwigPyIterator const *)arg1)->copy();
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_SwigPyIterator_next(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
PyObject *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:SwigPyIterator_next",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_next" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
}
arg1 = reinterpret_cast< swig::SwigPyIterator * >(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_SwigPyIterator___next__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
PyObject *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:SwigPyIterator___next__",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___next__" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
}
arg1 = reinterpret_cast< swig::SwigPyIterator * >(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_SwigPyIterator_previous(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
PyObject *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:SwigPyIterator_previous",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_previous" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
}
arg1 = reinterpret_cast< swig::SwigPyIterator * >(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_SwigPyIterator_advance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
ptrdiff_t arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
ptrdiff_t val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
swig::SwigPyIterator *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator_advance",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_advance" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
}
arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator_advance" "', argument " "2"" of type '" "ptrdiff_t""'");
}
arg2 = static_cast< ptrdiff_t >(val2);
try {
result = (swig::SwigPyIterator *)(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__SwigPyIterator, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_SwigPyIterator___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
swig::SwigPyIterator *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:SwigPyIterator___eq__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___eq__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
}
arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator___eq__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator___eq__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
}
arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
result = (bool)((swig::SwigPyIterator const *)arg1)->operator ==((swig::SwigPyIterator const &)*arg2);
resultobj = SWIG_From_bool(static_cast< bool >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_SwigPyIterator___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
swig::SwigPyIterator *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:SwigPyIterator___ne__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___ne__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
}
arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator___ne__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator___ne__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
}
arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
result = (bool)((swig::SwigPyIterator const *)arg1)->operator !=((swig::SwigPyIterator const &)*arg2);
resultobj = SWIG_From_bool(static_cast< bool >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_SwigPyIterator___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
ptrdiff_t arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
ptrdiff_t val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
swig::SwigPyIterator *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator___iadd__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___iadd__" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
}
arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___iadd__" "', argument " "2"" of type '" "ptrdiff_t""'");
}
arg2 = static_cast< ptrdiff_t >(val2);
try {
result = (swig::SwigPyIterator *) &(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__SwigPyIterator, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_SwigPyIterator___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
ptrdiff_t arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
ptrdiff_t val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
swig::SwigPyIterator *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator___isub__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___isub__" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
}
arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___isub__" "', argument " "2"" of type '" "ptrdiff_t""'");
}
arg2 = static_cast< ptrdiff_t >(val2);
try {
result = (swig::SwigPyIterator *) &(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__SwigPyIterator, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_SwigPyIterator___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
ptrdiff_t arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
ptrdiff_t val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
swig::SwigPyIterator *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator___add__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___add__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
}
arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___add__" "', argument " "2"" of type '" "ptrdiff_t""'");
}
arg2 = static_cast< ptrdiff_t >(val2);
try {
result = (swig::SwigPyIterator *)((swig::SwigPyIterator 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__SwigPyIterator, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_SwigPyIterator___sub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
ptrdiff_t arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
ptrdiff_t val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
swig::SwigPyIterator *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator___sub__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___sub__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
}
arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "ptrdiff_t""'");
}
arg2 = static_cast< ptrdiff_t >(val2);
try {
result = (swig::SwigPyIterator *)((swig::SwigPyIterator 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__SwigPyIterator, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_SwigPyIterator___sub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
swig::SwigPyIterator *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:SwigPyIterator___sub__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___sub__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
}
arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
}
arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
result = ((swig::SwigPyIterator const *)arg1)->operator -((swig::SwigPyIterator const &)*arg2);
resultobj = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_SwigPyIterator___sub__(PyObject *self, PyObject *args) {
Py_ssize_t argc;
PyObject *argv[3] = {
0
};
Py_ssize_t ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = args ? PyObject_Length(args) : 0;
for (ii = 0; (ii < 2) && (ii < argc); 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__SwigPyIterator, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_swig__SwigPyIterator, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_SwigPyIterator___sub____SWIG_1(self, args);
}
}
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_SwigPyIterator___sub____SWIG_0(self, args);
}
}
}
fail:
Py_INCREF(Py_NotImplemented);
return Py_NotImplemented;
}
SWIGINTERN PyObject *SwigPyIterator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_swig__SwigPyIterator, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_new_Matx_AddOp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx_AddOp *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new_Matx_AddOp")) SWIG_fail;
result = (cv::Matx_AddOp *)new cv::Matx_AddOp();
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__Matx_AddOp, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_Matx_AddOp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx_AddOp *arg1 = (cv::Matx_AddOp *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_Matx_AddOp",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__Matx_AddOp, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Matx_AddOp" "', argument " "1"" of type '" "cv::Matx_AddOp *""'");
}
arg1 = reinterpret_cast< cv::Matx_AddOp * >(argp1);
delete arg1;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *Matx_AddOp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_cv__Matx_AddOp, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_new_Matx_SubOp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx_SubOp *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new_Matx_SubOp")) SWIG_fail;
result = (cv::Matx_SubOp *)new cv::Matx_SubOp();
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__Matx_SubOp, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_Matx_SubOp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx_SubOp *arg1 = (cv::Matx_SubOp *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_Matx_SubOp",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__Matx_SubOp, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Matx_SubOp" "', argument " "1"" of type '" "cv::Matx_SubOp *""'");
}
arg1 = reinterpret_cast< cv::Matx_SubOp * >(argp1);
delete arg1;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *Matx_SubOp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_cv__Matx_SubOp, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_new_Matx_ScaleOp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx_ScaleOp *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new_Matx_ScaleOp")) SWIG_fail;
result = (cv::Matx_ScaleOp *)new cv::Matx_ScaleOp();
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__Matx_ScaleOp, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_Matx_ScaleOp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx_ScaleOp *arg1 = (cv::Matx_ScaleOp *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_Matx_ScaleOp",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__Matx_ScaleOp, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Matx_ScaleOp" "', argument " "1"" of type '" "cv::Matx_ScaleOp *""'");
}
arg1 = reinterpret_cast< cv::Matx_ScaleOp * >(argp1);
delete arg1;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *Matx_ScaleOp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_cv__Matx_ScaleOp, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_new_Matx_MulOp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx_MulOp *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new_Matx_MulOp")) SWIG_fail;
result = (cv::Matx_MulOp *)new cv::Matx_MulOp();
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__Matx_MulOp, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_Matx_MulOp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx_MulOp *arg1 = (cv::Matx_MulOp *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_Matx_MulOp",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__Matx_MulOp, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Matx_MulOp" "', argument " "1"" of type '" "cv::Matx_MulOp *""'");
}
arg1 = reinterpret_cast< cv::Matx_MulOp * >(argp1);
delete arg1;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *Matx_MulOp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_cv__Matx_MulOp, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_new_Matx_DivOp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx_DivOp *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new_Matx_DivOp")) SWIG_fail;
result = (cv::Matx_DivOp *)new cv::Matx_DivOp();
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__Matx_DivOp, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_Matx_DivOp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx_DivOp *arg1 = (cv::Matx_DivOp *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_Matx_DivOp",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__Matx_DivOp, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Matx_DivOp" "', argument " "1"" of type '" "cv::Matx_DivOp *""'");
}
arg1 = reinterpret_cast< cv::Matx_DivOp * >(argp1);
delete arg1;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *Matx_DivOp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_cv__Matx_DivOp, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_new_Matx_MatMulOp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx_MatMulOp *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new_Matx_MatMulOp")) SWIG_fail;
result = (cv::Matx_MatMulOp *)new cv::Matx_MatMulOp();
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__Matx_MatMulOp, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_Matx_MatMulOp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx_MatMulOp *arg1 = (cv::Matx_MatMulOp *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_Matx_MatMulOp",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__Matx_MatMulOp, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Matx_MatMulOp" "', argument " "1"" of type '" "cv::Matx_MatMulOp *""'");
}
arg1 = reinterpret_cast< cv::Matx_MatMulOp * >(argp1);
delete arg1;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *Matx_MatMulOp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_cv__Matx_MatMulOp, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_new_Matx_TOp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx_TOp *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new_Matx_TOp")) SWIG_fail;
result = (cv::Matx_TOp *)new cv::Matx_TOp();
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__Matx_TOp, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_Matx_TOp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx_TOp *arg1 = (cv::Matx_TOp *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_Matx_TOp",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__Matx_TOp, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Matx_TOp" "', argument " "1"" of type '" "cv::Matx_TOp *""'");
}
arg1 = reinterpret_cast< cv::Matx_TOp * >(argp1);
delete arg1;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *Matx_TOp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_cv__Matx_TOp, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_new_Mat__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Mat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new_Mat")) SWIG_fail;
result = (cv::Mat *)new cv::Mat();
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__Mat, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_Mat__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 ;
cv::Mat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new_Mat",&obj0,&obj1,&obj2)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Mat" "', 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_Mat" "', 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_Mat" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
result = (cv::Mat *)new cv::Mat(arg1,arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__Mat, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_Mat__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
SwigValueWrapper< cv::Size_< int > > arg1 ;
int arg2 ;
void *argp1 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
cv::Mat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:new_Mat",&obj0,&obj1)) SWIG_fail;
{
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__Size_T_int_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Mat" "', argument " "1"" of type '" "cv::Size""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Mat" "', argument " "1"" of type '" "cv::Size""'");
} else {
cv::Size * temp = reinterpret_cast< cv::Size * >(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_Mat" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
result = (cv::Mat *)new cv::Mat(arg1,arg2);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__Mat, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_Mat__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
int arg3 ;
cv::Scalar *arg4 = 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 ;
cv::Mat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOO:new_Mat",&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_Mat" "', 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_Mat" "', 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_Mat" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_cv__Scalar_T_double_t, 0 | 0);
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Mat" "', argument " "4"" of type '" "cv::Scalar const &""'");
}
if (!argp4) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Mat" "', argument " "4"" of type '" "cv::Scalar const &""'");
}
arg4 = reinterpret_cast< cv::Scalar * >(argp4);
result = (cv::Mat *)new cv::Mat(arg1,arg2,arg3,(cv::Scalar const &)*arg4);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__Mat, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_Mat__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
SwigValueWrapper< cv::Size_< int > > arg1 ;
int arg2 ;
cv::Scalar *arg3 = 0 ;
void *argp1 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
void *argp3 = 0 ;
int res3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
cv::Mat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new_Mat",&obj0,&obj1,&obj2)) SWIG_fail;
{
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__Size_T_int_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Mat" "', argument " "1"" of type '" "cv::Size""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Mat" "', argument " "1"" of type '" "cv::Size""'");
} else {
cv::Size * temp = reinterpret_cast< cv::Size * >(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_Mat" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Scalar_T_double_t, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Mat" "', argument " "3"" of type '" "cv::Scalar const &""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Mat" "', argument " "3"" of type '" "cv::Scalar const &""'");
}
arg3 = reinterpret_cast< cv::Scalar * >(argp3);
result = (cv::Mat *)new cv::Mat(arg1,arg2,(cv::Scalar const &)*arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__Mat, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_Mat__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int *arg2 = (int *) 0 ;
int arg3 ;
int val1 ;
int ecode1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
int val3 ;
int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
cv::Mat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new_Mat",&obj0,&obj1,&obj2)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Mat" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_int, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Mat" "', argument " "2"" of type '" "int const *""'");
}
arg2 = reinterpret_cast< int * >(argp2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Mat" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
result = (cv::Mat *)new cv::Mat(arg1,(int const *)arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__Mat, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_Mat__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int *arg2 = (int *) 0 ;
int arg3 ;
cv::Scalar *arg4 = 0 ;
int val1 ;
int ecode1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
int val3 ;
int ecode3 = 0 ;
void *argp4 = 0 ;
int res4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
cv::Mat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOO:new_Mat",&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_Mat" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_int, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Mat" "', argument " "2"" of type '" "int const *""'");
}
arg2 = reinterpret_cast< int * >(argp2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Mat" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_cv__Scalar_T_double_t, 0 | 0);
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Mat" "', argument " "4"" of type '" "cv::Scalar const &""'");
}
if (!argp4) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Mat" "', argument " "4"" of type '" "cv::Scalar const &""'");
}
arg4 = reinterpret_cast< cv::Scalar * >(argp4);
result = (cv::Mat *)new cv::Mat(arg1,(int const *)arg2,arg3,(cv::Scalar const &)*arg4);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__Mat, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_Mat__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Mat *arg1 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
cv::Mat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new_Mat",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__Mat, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Mat" "', argument " "1"" of type '" "cv::Mat const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Mat" "', argument " "1"" of type '" "cv::Mat const &""'");
}
arg1 = reinterpret_cast< cv::Mat * >(argp1);
result = (cv::Mat *)new cv::Mat((cv::Mat const &)*arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__Mat, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_Mat__SWIG_8(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
int arg3 ;
void *arg4 = (void *) 0 ;
size_t arg5 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
int res4 ;
size_t val5 ;
int ecode5 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
cv::Mat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOO:new_Mat",&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_Mat" "', 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_Mat" "', 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_Mat" "', 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_Mat" "', argument " "4"" of type '" "void *""'");
}
ecode5 = SWIG_AsVal_size_t(obj4, &val5);
if (!SWIG_IsOK(ecode5)) {
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Mat" "', argument " "5"" of type '" "size_t""'");
}
arg5 = static_cast< size_t >(val5);
result = (cv::Mat *)new cv::Mat(arg1,arg2,arg3,arg4,arg5);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__Mat, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_Mat__SWIG_9(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 ;
cv::Mat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOO:new_Mat",&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_Mat" "', 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_Mat" "', 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_Mat" "', 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_Mat" "', argument " "4"" of type '" "void *""'");
}
result = (cv::Mat *)new cv::Mat(arg1,arg2,arg3,arg4);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__Mat, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_Mat__SWIG_10(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
SwigValueWrapper< cv::Size_< int > > arg1 ;
int arg2 ;
void *arg3 = (void *) 0 ;
size_t arg4 ;
void *argp1 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int res3 ;
size_t val4 ;
int ecode4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
cv::Mat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOO:new_Mat",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
{
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__Size_T_int_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Mat" "', argument " "1"" of type '" "cv::Size""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Mat" "', argument " "1"" of type '" "cv::Size""'");
} else {
cv::Size * temp = reinterpret_cast< cv::Size * >(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_Mat" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3), 0, 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Mat" "', argument " "3"" of type '" "void *""'");
}
ecode4 = SWIG_AsVal_size_t(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Mat" "', argument " "4"" of type '" "size_t""'");
}
arg4 = static_cast< size_t >(val4);
result = (cv::Mat *)new cv::Mat(arg1,arg2,arg3,arg4);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__Mat, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_Mat__SWIG_11(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
SwigValueWrapper< cv::Size_< int > > arg1 ;
int arg2 ;
void *arg3 = (void *) 0 ;
void *argp1 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int res3 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
cv::Mat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new_Mat",&obj0,&obj1,&obj2)) SWIG_fail;
{
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__Size_T_int_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Mat" "', argument " "1"" of type '" "cv::Size""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Mat" "', argument " "1"" of type '" "cv::Size""'");
} else {
cv::Size * temp = reinterpret_cast< cv::Size * >(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_Mat" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3), 0, 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Mat" "', argument " "3"" of type '" "void *""'");
}
result = (cv::Mat *)new cv::Mat(arg1,arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__Mat, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_Mat__SWIG_12(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int *arg2 = (int *) 0 ;
int arg3 ;
void *arg4 = (void *) 0 ;
size_t *arg5 = (size_t *) 0 ;
int val1 ;
int ecode1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
int val3 ;
int ecode3 = 0 ;
int res4 ;
void *argp5 = 0 ;
int res5 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
cv::Mat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOO:new_Mat",&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_Mat" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_int, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Mat" "', argument " "2"" of type '" "int const *""'");
}
arg2 = reinterpret_cast< int * >(argp2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Mat" "', 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_Mat" "', argument " "4"" of type '" "void *""'");
}
res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_size_t, 0 | 0 );
if (!SWIG_IsOK(res5)) {
SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_Mat" "', argument " "5"" of type '" "size_t const *""'");
}
arg5 = reinterpret_cast< size_t * >(argp5);
result = (cv::Mat *)new cv::Mat(arg1,(int const *)arg2,arg3,arg4,(size_t const *)arg5);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__Mat, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_Mat__SWIG_13(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int *arg2 = (int *) 0 ;
int arg3 ;
void *arg4 = (void *) 0 ;
int val1 ;
int ecode1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
int val3 ;
int ecode3 = 0 ;
int res4 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
cv::Mat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOO:new_Mat",&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_Mat" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_int, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Mat" "', argument " "2"" of type '" "int const *""'");
}
arg2 = reinterpret_cast< int * >(argp2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Mat" "', 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_Mat" "', argument " "4"" of type '" "void *""'");
}
result = (cv::Mat *)new cv::Mat(arg1,(int const *)arg2,arg3,arg4);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__Mat, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_Mat__SWIG_14(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Mat *arg1 = 0 ;
cv::Range *arg2 = 0 ;
cv::Range *arg3 = 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 ;
cv::Mat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new_Mat",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__Mat, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Mat" "', argument " "1"" of type '" "cv::Mat const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Mat" "', argument " "1"" of type '" "cv::Mat const &""'");
}
arg1 = reinterpret_cast< cv::Mat * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__Range, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Mat" "', argument " "2"" of type '" "cv::Range const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Mat" "', argument " "2"" of type '" "cv::Range const &""'");
}
arg2 = reinterpret_cast< cv::Range * >(argp2);
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Range, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Mat" "', argument " "3"" of type '" "cv::Range const &""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Mat" "', argument " "3"" of type '" "cv::Range const &""'");
}
arg3 = reinterpret_cast< cv::Range * >(argp3);
result = (cv::Mat *)new cv::Mat((cv::Mat const &)*arg1,(cv::Range const &)*arg2,(cv::Range const &)*arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__Mat, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_Mat__SWIG_15(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Mat *arg1 = 0 ;
cv::Range *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
cv::Mat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:new_Mat",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__Mat, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Mat" "', argument " "1"" of type '" "cv::Mat const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Mat" "', argument " "1"" of type '" "cv::Mat const &""'");
}
arg1 = reinterpret_cast< cv::Mat * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__Range, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Mat" "', argument " "2"" of type '" "cv::Range const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Mat" "', argument " "2"" of type '" "cv::Range const &""'");
}
arg2 = reinterpret_cast< cv::Range * >(argp2);
result = (cv::Mat *)new cv::Mat((cv::Mat const &)*arg1,(cv::Range const &)*arg2);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__Mat, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_Mat__SWIG_16(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Mat *arg1 = 0 ;
cv::Rect *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
cv::Mat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:new_Mat",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__Mat, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Mat" "', argument " "1"" of type '" "cv::Mat const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Mat" "', argument " "1"" of type '" "cv::Mat const &""'");
}
arg1 = reinterpret_cast< cv::Mat * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__Rect_T_int_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Mat" "', argument " "2"" of type '" "cv::Rect const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Mat" "', argument " "2"" of type '" "cv::Rect const &""'");
}
arg2 = reinterpret_cast< cv::Rect * >(argp2);
result = (cv::Mat *)new cv::Mat((cv::Mat const &)*arg1,(cv::Rect const &)*arg2);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__Mat, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_Mat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Mat *arg1 = (cv::Mat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_Mat",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__Mat, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Mat" "', argument " "1"" of type '" "cv::Mat *""'");
}
arg1 = reinterpret_cast< cv::Mat * >(argp1);
delete arg1;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Mat_row(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Mat *arg1 = (cv::Mat *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
cv::Mat result;
if (!PyArg_ParseTuple(args,(char *)"OO:Mat_row",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__Mat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mat_row" "', argument " "1"" of type '" "cv::Mat const *""'");
}
arg1 = reinterpret_cast< cv::Mat * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Mat_row" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
result = ((cv::Mat const *)arg1)->row(arg2);
resultobj = SWIG_NewPointerObj((new cv::Mat(static_cast< const cv::Mat& >(result))), SWIGTYPE_p_cv__Mat, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Mat_col(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Mat *arg1 = (cv::Mat *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
cv::Mat result;
if (!PyArg_ParseTuple(args,(char *)"OO:Mat_col",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__Mat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mat_col" "', argument " "1"" of type '" "cv::Mat const *""'");
}
arg1 = reinterpret_cast< cv::Mat * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Mat_col" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
result = ((cv::Mat const *)arg1)->col(arg2);
resultobj = SWIG_NewPointerObj((new cv::Mat(static_cast< const cv::Mat& >(result))), SWIGTYPE_p_cv__Mat, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Mat_rowRange__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Mat *arg1 = (cv::Mat *) 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 ;
cv::Mat result;
if (!PyArg_ParseTuple(args,(char *)"OOO:Mat_rowRange",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__Mat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mat_rowRange" "', argument " "1"" of type '" "cv::Mat const *""'");
}
arg1 = reinterpret_cast< cv::Mat * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Mat_rowRange" "', 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 '" "Mat_rowRange" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
result = ((cv::Mat const *)arg1)->rowRange(arg2,arg3);
resultobj = SWIG_NewPointerObj((new cv::Mat(static_cast< const cv::Mat& >(result))), SWIGTYPE_p_cv__Mat, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Mat_rowRange__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Mat *arg1 = (cv::Mat *) 0 ;
cv::Range *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
cv::Mat result;
if (!PyArg_ParseTuple(args,(char *)"OO:Mat_rowRange",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__Mat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mat_rowRange" "', argument " "1"" of type '" "cv::Mat const *""'");
}
arg1 = reinterpret_cast< cv::Mat * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__Range, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mat_rowRange" "', argument " "2"" of type '" "cv::Range const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mat_rowRange" "', argument " "2"" of type '" "cv::Range const &""'");
}
arg2 = reinterpret_cast< cv::Range * >(argp2);
result = ((cv::Mat const *)arg1)->rowRange((cv::Range const &)*arg2);
resultobj = SWIG_NewPointerObj((new cv::Mat(static_cast< const cv::Mat& >(result))), SWIGTYPE_p_cv__Mat, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Mat_rowRange(PyObject *self, PyObject *args) {
Py_ssize_t argc;
PyObject *argv[4] = {
0
};
Py_ssize_t ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = args ? PyObject_Length(args) : 0;
for (ii = 0; (ii < 3) && (ii < argc); 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_cv__Mat, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__Range, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_Mat_rowRange__SWIG_1(self, args);
}
}
}
if (argc == 3) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cv__Mat, 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_Mat_rowRange__SWIG_0(self, args);
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Mat_rowRange'.\n"
" Possible C/C++ prototypes are:\n"
" cv::Mat::rowRange(int,int) const\n"
" cv::Mat::rowRange(cv::Range const &) const\n");
return 0;
}
SWIGINTERN PyObject *_wrap_Mat_colRange__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Mat *arg1 = (cv::Mat *) 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 ;
cv::Mat result;
if (!PyArg_ParseTuple(args,(char *)"OOO:Mat_colRange",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__Mat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mat_colRange" "', argument " "1"" of type '" "cv::Mat const *""'");
}
arg1 = reinterpret_cast< cv::Mat * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Mat_colRange" "', 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 '" "Mat_colRange" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
result = ((cv::Mat const *)arg1)->colRange(arg2,arg3);
resultobj = SWIG_NewPointerObj((new cv::Mat(static_cast< const cv::Mat& >(result))), SWIGTYPE_p_cv__Mat, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Mat_colRange__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Mat *arg1 = (cv::Mat *) 0 ;
cv::Range *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
cv::Mat result;
if (!PyArg_ParseTuple(args,(char *)"OO:Mat_colRange",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__Mat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mat_colRange" "', argument " "1"" of type '" "cv::Mat const *""'");
}
arg1 = reinterpret_cast< cv::Mat * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__Range, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mat_colRange" "', argument " "2"" of type '" "cv::Range const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mat_colRange" "', argument " "2"" of type '" "cv::Range const &""'");
}
arg2 = reinterpret_cast< cv::Range * >(argp2);
result = ((cv::Mat const *)arg1)->colRange((cv::Range const &)*arg2);
resultobj = SWIG_NewPointerObj((new cv::Mat(static_cast< const cv::Mat& >(result))), SWIGTYPE_p_cv__Mat, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Mat_colRange(PyObject *self, PyObject *args) {
Py_ssize_t argc;
PyObject *argv[4] = {
0
};
Py_ssize_t ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = args ? PyObject_Length(args) : 0;
for (ii = 0; (ii < 3) && (ii < argc); 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_cv__Mat, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__Range, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_Mat_colRange__SWIG_1(self, args);
}
}
}
if (argc == 3) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cv__Mat, 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_Mat_colRange__SWIG_0(self, args);
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Mat_colRange'.\n"
" Possible C/C++ prototypes are:\n"
" cv::Mat::colRange(int,int) const\n"
" cv::Mat::colRange(cv::Range const &) const\n");
return 0;
}
SWIGINTERN PyObject *_wrap_Mat_diag__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Mat *arg1 = (cv::Mat *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
cv::Mat result;
if (!PyArg_ParseTuple(args,(char *)"OO:Mat_diag",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__Mat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mat_diag" "', argument " "1"" of type '" "cv::Mat const *""'");
}
arg1 = reinterpret_cast< cv::Mat * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Mat_diag" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
result = ((cv::Mat const *)arg1)->diag(arg2);
resultobj = SWIG_NewPointerObj((new cv::Mat(static_cast< const cv::Mat& >(result))), SWIGTYPE_p_cv__Mat, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Mat_diag__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Mat *arg1 = (cv::Mat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
cv::Mat result;
if (!PyArg_ParseTuple(args,(char *)"O:Mat_diag",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__Mat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mat_diag" "', argument " "1"" of type '" "cv::Mat const *""'");
}
arg1 = reinterpret_cast< cv::Mat * >(argp1);
result = ((cv::Mat const *)arg1)->diag();
resultobj = SWIG_NewPointerObj((new cv::Mat(static_cast< const cv::Mat& >(result))), SWIGTYPE_p_cv__Mat, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Mat_diag(PyObject *self, PyObject *args) {
Py_ssize_t argc;
PyObject *argv[3] = {
0
};
Py_ssize_t ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = args ? PyObject_Length(args) : 0;
for (ii = 0; (ii < 2) && (ii < argc); 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_cv__Mat, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_Mat_diag__SWIG_1(self, args);
}
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cv__Mat, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_Mat_diag__SWIG_0(self, args);
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Mat_diag'.\n"
" Possible C/C++ prototypes are:\n"
" cv::Mat::diag(int) const\n"
" cv::Mat::diag() const\n");
return 0;
}
SWIGINTERN PyObject *_wrap_Mat_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Mat *arg1 = (cv::Mat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
cv::Mat result;
if (!PyArg_ParseTuple(args,(char *)"O:Mat_clone",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__Mat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mat_clone" "', argument " "1"" of type '" "cv::Mat const *""'");
}
arg1 = reinterpret_cast< cv::Mat * >(argp1);
result = ((cv::Mat const *)arg1)->clone();
resultobj = SWIG_NewPointerObj((new cv::Mat(static_cast< const cv::Mat& >(result))), SWIGTYPE_p_cv__Mat, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Mat_assignTo__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Mat *arg1 = (cv::Mat *) 0 ;
cv::Mat *arg2 = 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 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:Mat_assignTo",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__Mat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mat_assignTo" "', argument " "1"" of type '" "cv::Mat const *""'");
}
arg1 = reinterpret_cast< cv::Mat * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__Mat, 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mat_assignTo" "', argument " "2"" of type '" "cv::Mat &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mat_assignTo" "', argument " "2"" of type '" "cv::Mat &""'");
}
arg2 = reinterpret_cast< cv::Mat * >(argp2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Mat_assignTo" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
((cv::Mat const *)arg1)->assignTo(*arg2,arg3);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Mat_assignTo__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Mat *arg1 = (cv::Mat *) 0 ;
cv::Mat *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:Mat_assignTo",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__Mat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mat_assignTo" "', argument " "1"" of type '" "cv::Mat const *""'");
}
arg1 = reinterpret_cast< cv::Mat * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__Mat, 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mat_assignTo" "', argument " "2"" of type '" "cv::Mat &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mat_assignTo" "', argument " "2"" of type '" "cv::Mat &""'");
}
arg2 = reinterpret_cast< cv::Mat * >(argp2);
((cv::Mat const *)arg1)->assignTo(*arg2);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Mat_assignTo(PyObject *self, PyObject *args) {
Py_ssize_t argc;
PyObject *argv[4] = {
0
};
Py_ssize_t ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = args ? PyObject_Length(args) : 0;
for (ii = 0; (ii < 3) && (ii < argc); 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_cv__Mat, 0);
_v = SWIG_CheckState(res);
if (_v) {
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_cv__Mat, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_Mat_assignTo__SWIG_1(self, args);
}
}
}
if (argc == 3) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cv__Mat, 0);
_v = SWIG_CheckState(res);
if (_v) {
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_cv__Mat, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_Mat_assignTo__SWIG_0(self, args);
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Mat_assignTo'.\n"
" Possible C/C++ prototypes are:\n"
" cv::Mat::assignTo(cv::Mat &,int) const\n"
" cv::Mat::assignTo(cv::Mat &) const\n");
return 0;
}
SWIGINTERN PyObject *_wrap_Mat_reshape__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Mat *arg1 = (cv::Mat *) 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 ;
cv::Mat result;
if (!PyArg_ParseTuple(args,(char *)"OOO:Mat_reshape",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__Mat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mat_reshape" "', argument " "1"" of type '" "cv::Mat const *""'");
}
arg1 = reinterpret_cast< cv::Mat * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Mat_reshape" "', 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 '" "Mat_reshape" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
result = ((cv::Mat const *)arg1)->reshape(arg2,arg3);
resultobj = SWIG_NewPointerObj((new cv::Mat(static_cast< const cv::Mat& >(result))), SWIGTYPE_p_cv__Mat, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Mat_reshape__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Mat *arg1 = (cv::Mat *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
cv::Mat result;
if (!PyArg_ParseTuple(args,(char *)"OO:Mat_reshape",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__Mat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mat_reshape" "', argument " "1"" of type '" "cv::Mat const *""'");
}
arg1 = reinterpret_cast< cv::Mat * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Mat_reshape" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
result = ((cv::Mat const *)arg1)->reshape(arg2);
resultobj = SWIG_NewPointerObj((new cv::Mat(static_cast< const cv::Mat& >(result))), SWIGTYPE_p_cv__Mat, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Mat_reshape__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Mat *arg1 = (cv::Mat *) 0 ;
int arg2 ;
int arg3 ;
int *arg4 = (int *) 0 ;
void *argp1 = 0 ;
int res1 = 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 ;
cv::Mat result;
if (!PyArg_ParseTuple(args,(char *)"OOOO:Mat_reshape",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__Mat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mat_reshape" "', argument " "1"" of type '" "cv::Mat const *""'");
}
arg1 = reinterpret_cast< cv::Mat * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Mat_reshape" "', 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 '" "Mat_reshape" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_int, 0 | 0 );
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Mat_reshape" "', argument " "4"" of type '" "int const *""'");
}
arg4 = reinterpret_cast< int * >(argp4);
result = ((cv::Mat const *)arg1)->reshape(arg2,arg3,(int const *)arg4);
resultobj = SWIG_NewPointerObj((new cv::Mat(static_cast< const cv::Mat& >(result))), SWIGTYPE_p_cv__Mat, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Mat_reshape(PyObject *self, PyObject *args) {
Py_ssize_t argc;
PyObject *argv[5] = {
0
};
Py_ssize_t ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = args ? PyObject_Length(args) : 0;
for (ii = 0; (ii < 4) && (ii < argc); 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_cv__Mat, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_Mat_reshape__SWIG_1(self, args);
}
}
}
if (argc == 3) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cv__Mat, 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_Mat_reshape__SWIG_0(self, args);
}
}
}
}
if (argc == 4) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cv__Mat, 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) {
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_int, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_Mat_reshape__SWIG_2(self, args);
}
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Mat_reshape'.\n"
" Possible C/C++ prototypes are:\n"
" cv::Mat::reshape(int,int) const\n"
" cv::Mat::reshape(int) const\n"
" cv::Mat::reshape(int,int,int const *) const\n");
return 0;
}
SWIGINTERN PyObject *_wrap_Mat_create__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Mat *arg1 = (cv::Mat *) 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:Mat_create",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__Mat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mat_create" "', argument " "1"" of type '" "cv::Mat *""'");
}
arg1 = reinterpret_cast< cv::Mat * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Mat_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 '" "Mat_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 '" "Mat_create" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
(arg1)->create(arg2,arg3,arg4);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Mat_create__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Mat *arg1 = (cv::Mat *) 0 ;
SwigValueWrapper< cv::Size_< int > > arg2 ;
int arg3 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 ;
int res2 = 0 ;
int val3 ;
int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:Mat_create",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__Mat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mat_create" "', argument " "1"" of type '" "cv::Mat *""'");
}
arg1 = reinterpret_cast< cv::Mat * >(argp1);
{
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__Size_T_int_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mat_create" "', argument " "2"" of type '" "cv::Size""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mat_create" "', argument " "2"" of type '" "cv::Size""'");
} else {
cv::Size * temp = reinterpret_cast< cv::Size * >(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 '" "Mat_create" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
(arg1)->create(arg2,arg3);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Mat_create__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Mat *arg1 = (cv::Mat *) 0 ;
int arg2 ;
int *arg3 = (int *) 0 ;
int arg4 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 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:Mat_create",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__Mat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mat_create" "', argument " "1"" of type '" "cv::Mat *""'");
}
arg1 = reinterpret_cast< cv::Mat * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Mat_create" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_int, 0 | 0 );
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mat_create" "', argument " "3"" of type '" "int const *""'");
}
arg3 = reinterpret_cast< int * >(argp3);
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Mat_create" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
(arg1)->create(arg2,(int const *)arg3,arg4);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Mat_create(PyObject *self, PyObject *args) {
Py_ssize_t argc;
PyObject *argv[5] = {
0
};
Py_ssize_t ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = args ? PyObject_Length(args) : 0;
for (ii = 0; (ii < 4) && (ii < argc); 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_cv__Mat, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__Size_T_int_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_Mat_create__SWIG_1(self, args);
}
}
}
}
if (argc == 4) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cv__Mat, 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_int, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[3], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_Mat_create__SWIG_2(self, args);
}
}
}
}
}
if (argc == 4) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cv__Mat, 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) {
return _wrap_Mat_create__SWIG_0(self, args);
}
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Mat_create'.\n"
" Possible C/C++ prototypes are:\n"
" cv::Mat::create(int,int,int)\n"
" cv::Mat::create(cv::Size,int)\n"
" cv::Mat::create(int,int const *,int)\n");
return 0;
}
SWIGINTERN PyObject *_wrap_Mat_addref(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Mat *arg1 = (cv::Mat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:Mat_addref",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__Mat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mat_addref" "', argument " "1"" of type '" "cv::Mat *""'");
}
arg1 = reinterpret_cast< cv::Mat * >(argp1);
(arg1)->addref();
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Mat_release(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Mat *arg1 = (cv::Mat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:Mat_release",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__Mat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mat_release" "', argument " "1"" of type '" "cv::Mat *""'");
}
arg1 = reinterpret_cast< cv::Mat * >(argp1);
(arg1)->release();
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Mat_deallocate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Mat *arg1 = (cv::Mat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:Mat_deallocate",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__Mat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mat_deallocate" "', argument " "1"" of type '" "cv::Mat *""'");
}
arg1 = reinterpret_cast< cv::Mat * >(argp1);
(arg1)->deallocate();
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Mat_copySize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Mat *arg1 = (cv::Mat *) 0 ;
cv::Mat *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:Mat_copySize",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__Mat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mat_copySize" "', argument " "1"" of type '" "cv::Mat *""'");
}
arg1 = reinterpret_cast< cv::Mat * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__Mat, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mat_copySize" "', argument " "2"" of type '" "cv::Mat const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mat_copySize" "', argument " "2"" of type '" "cv::Mat const &""'");
}
arg2 = reinterpret_cast< cv::Mat * >(argp2);
(arg1)->copySize((cv::Mat const &)*arg2);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Mat_reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Mat *arg1 = (cv::Mat *) 0 ;
size_t 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:Mat_reserve",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__Mat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mat_reserve" "', argument " "1"" of type '" "cv::Mat *""'");
}
arg1 = reinterpret_cast< cv::Mat * >(argp1);
ecode2 = SWIG_AsVal_size_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Mat_reserve" "', argument " "2"" of type '" "size_t""'");
}
arg2 = static_cast< size_t >(val2);
(arg1)->reserve(arg2);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Mat_resize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Mat *arg1 = (cv::Mat *) 0 ;
size_t 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:Mat_resize",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__Mat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mat_resize" "', argument " "1"" of type '" "cv::Mat *""'");
}
arg1 = reinterpret_cast< cv::Mat * >(argp1);
ecode2 = SWIG_AsVal_size_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Mat_resize" "', argument " "2"" of type '" "size_t""'");
}
arg2 = static_cast< size_t >(val2);
(arg1)->resize(arg2);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Mat_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Mat *arg1 = (cv::Mat *) 0 ;
size_t arg2 ;
cv::Scalar *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:Mat_resize",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__Mat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mat_resize" "', argument " "1"" of type '" "cv::Mat *""'");
}
arg1 = reinterpret_cast< cv::Mat * >(argp1);
ecode2 = SWIG_AsVal_size_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Mat_resize" "', argument " "2"" of type '" "size_t""'");
}
arg2 = static_cast< size_t >(val2);
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Scalar_T_double_t, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mat_resize" "', argument " "3"" of type '" "cv::Scalar const &""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mat_resize" "', argument " "3"" of type '" "cv::Scalar const &""'");
}
arg3 = reinterpret_cast< cv::Scalar * >(argp3);
(arg1)->resize(arg2,(cv::Scalar const &)*arg3);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Mat_resize(PyObject *self, PyObject *args) {
Py_ssize_t argc;
PyObject *argv[4] = {
0
};
Py_ssize_t ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = args ? PyObject_Length(args) : 0;
for (ii = 0; (ii < 3) && (ii < argc); 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_cv__Mat, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_size_t(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_Mat_resize__SWIG_0(self, args);
}
}
}
if (argc == 3) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cv__Mat, 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_cv__Scalar_T_double_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_Mat_resize__SWIG_1(self, args);
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Mat_resize'.\n"
" Possible C/C++ prototypes are:\n"
" cv::Mat::resize(size_t)\n"
" cv::Mat::resize(size_t,cv::Scalar const &)\n");
return 0;
}
SWIGINTERN PyObject *_wrap_Mat_push_back_(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Mat *arg1 = (cv::Mat *) 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:Mat_push_back_",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__Mat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mat_push_back_" "', argument " "1"" of type '" "cv::Mat *""'");
}
arg1 = reinterpret_cast< cv::Mat * >(argp1);
res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mat_push_back_" "', argument " "2"" of type '" "void const *""'");
}
(arg1)->push_back_((void const *)arg2);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Mat_push_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Mat *arg1 = (cv::Mat *) 0 ;
cv::Mat *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:Mat_push_back",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__Mat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mat_push_back" "', argument " "1"" of type '" "cv::Mat *""'");
}
arg1 = reinterpret_cast< cv::Mat * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__Mat, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mat_push_back" "', argument " "2"" of type '" "cv::Mat const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mat_push_back" "', argument " "2"" of type '" "cv::Mat const &""'");
}
arg2 = reinterpret_cast< cv::Mat * >(argp2);
(arg1)->push_back((cv::Mat const &)*arg2);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Mat_pop_back__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Mat *arg1 = (cv::Mat *) 0 ;
size_t 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:Mat_pop_back",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__Mat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mat_pop_back" "', argument " "1"" of type '" "cv::Mat *""'");
}
arg1 = reinterpret_cast< cv::Mat * >(argp1);
ecode2 = SWIG_AsVal_size_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Mat_pop_back" "', argument " "2"" of type '" "size_t""'");
}
arg2 = static_cast< size_t >(val2);
(arg1)->pop_back(arg2);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Mat_pop_back__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Mat *arg1 = (cv::Mat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:Mat_pop_back",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__Mat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mat_pop_back" "', argument " "1"" of type '" "cv::Mat *""'");
}
arg1 = reinterpret_cast< cv::Mat * >(argp1);
(arg1)->pop_back();
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Mat_pop_back(PyObject *self, PyObject *args) {
Py_ssize_t argc;
PyObject *argv[3] = {
0
};
Py_ssize_t ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = args ? PyObject_Length(args) : 0;
for (ii = 0; (ii < 2) && (ii < argc); 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_cv__Mat, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_Mat_pop_back__SWIG_1(self, args);
}
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cv__Mat, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_size_t(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_Mat_pop_back__SWIG_0(self, args);
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Mat_pop_back'.\n"
" Possible C/C++ prototypes are:\n"
" cv::Mat::pop_back(size_t)\n"
" cv::Mat::pop_back()\n");
return 0;
}
SWIGINTERN PyObject *_wrap_Mat_locateROI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Mat *arg1 = (cv::Mat *) 0 ;
cv::Size *arg2 = 0 ;
cv::Point *arg3 = 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:Mat_locateROI",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__Mat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mat_locateROI" "', argument " "1"" of type '" "cv::Mat const *""'");
}
arg1 = reinterpret_cast< cv::Mat * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__Size_T_int_t, 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mat_locateROI" "', argument " "2"" of type '" "cv::Size &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mat_locateROI" "', argument " "2"" of type '" "cv::Size &""'");
}
arg2 = reinterpret_cast< cv::Size * >(argp2);
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Point_T_int_t, 0 );
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mat_locateROI" "', argument " "3"" of type '" "cv::Point &""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mat_locateROI" "', argument " "3"" of type '" "cv::Point &""'");
}
arg3 = reinterpret_cast< cv::Point * >(argp3);
((cv::Mat const *)arg1)->locateROI(*arg2,*arg3);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Mat_adjustROI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Mat *arg1 = (cv::Mat *) 0 ;
int arg2 ;
int arg3 ;
int arg4 ;
int arg5 ;
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 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
cv::Mat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOO:Mat_adjustROI",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__Mat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mat_adjustROI" "', argument " "1"" of type '" "cv::Mat *""'");
}
arg1 = reinterpret_cast< cv::Mat * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Mat_adjustROI" "', 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 '" "Mat_adjustROI" "', 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 '" "Mat_adjustROI" "', 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 '" "Mat_adjustROI" "', argument " "5"" of type '" "int""'");
}
arg5 = static_cast< int >(val5);
result = (cv::Mat *) &(arg1)->adjustROI(arg2,arg3,arg4,arg5);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__Mat, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Mat___call____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Mat *arg1 = (cv::Mat *) 0 ;
cv::Range arg2 ;
cv::Range arg3 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 ;
int res2 = 0 ;
void *argp3 ;
int res3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
cv::Mat result;
if (!PyArg_ParseTuple(args,(char *)"OOO:Mat___call__",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__Mat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mat___call__" "', argument " "1"" of type '" "cv::Mat const *""'");
}
arg1 = reinterpret_cast< cv::Mat * >(argp1);
{
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__Range, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mat___call__" "', argument " "2"" of type '" "cv::Range""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mat___call__" "', argument " "2"" of type '" "cv::Range""'");
} else {
cv::Range * temp = reinterpret_cast< cv::Range * >(argp2);
arg2 = *temp;
if (SWIG_IsNewObj(res2)) delete temp;
}
}
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Range, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mat___call__" "', argument " "3"" of type '" "cv::Range""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mat___call__" "', argument " "3"" of type '" "cv::Range""'");
} else {
cv::Range * temp = reinterpret_cast< cv::Range * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = ((cv::Mat const *)arg1)->operator ()(arg2,arg3);
resultobj = SWIG_NewPointerObj((new cv::Mat(static_cast< const cv::Mat& >(result))), SWIGTYPE_p_cv__Mat, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Mat___call____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Mat *arg1 = (cv::Mat *) 0 ;
cv::Rect *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
cv::Mat result;
if (!PyArg_ParseTuple(args,(char *)"OO:Mat___call__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__Mat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mat___call__" "', argument " "1"" of type '" "cv::Mat const *""'");
}
arg1 = reinterpret_cast< cv::Mat * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__Rect_T_int_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mat___call__" "', argument " "2"" of type '" "cv::Rect const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mat___call__" "', argument " "2"" of type '" "cv::Rect const &""'");
}
arg2 = reinterpret_cast< cv::Rect * >(argp2);
result = ((cv::Mat const *)arg1)->operator ()((cv::Rect const &)*arg2);
resultobj = SWIG_NewPointerObj((new cv::Mat(static_cast< const cv::Mat& >(result))), SWIGTYPE_p_cv__Mat, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Mat___call____SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Mat *arg1 = (cv::Mat *) 0 ;
cv::Range *arg2 = (cv::Range *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
cv::Mat result;
if (!PyArg_ParseTuple(args,(char *)"OO:Mat___call__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__Mat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mat___call__" "', argument " "1"" of type '" "cv::Mat const *""'");
}
arg1 = reinterpret_cast< cv::Mat * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_cv__Range, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mat___call__" "', argument " "2"" of type '" "cv::Range const *""'");
}
arg2 = reinterpret_cast< cv::Range * >(argp2);
result = ((cv::Mat const *)arg1)->operator ()((cv::Range const *)arg2);
resultobj = SWIG_NewPointerObj((new cv::Mat(static_cast< const cv::Mat& >(result))), SWIGTYPE_p_cv__Mat, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Mat___call__(PyObject *self, PyObject *args) {
Py_ssize_t argc;
PyObject *argv[4] = {
0
};
Py_ssize_t ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = args ? PyObject_Length(args) : 0;
for (ii = 0; (ii < 3) && (ii < argc); 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_cv__Mat, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__Rect_T_int_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_Mat___call____SWIG_1(self, args);
}
}
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cv__Mat, 0);
_v = SWIG_CheckState(res);
if (_v) {
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_cv__Range, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_Mat___call____SWIG_2(self, args);
}
}
}
if (argc == 3) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cv__Mat, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__Range, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Range, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_Mat___call____SWIG_0(self, args);
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Mat___call__'.\n"
" Possible C/C++ prototypes are:\n"
" cv::Mat::operator ()(cv::Range,cv::Range) const\n"
" cv::Mat::operator ()(cv::Rect const &) const\n"
" cv::Mat::operator ()(cv::Range const *) const\n");
return 0;
}
SWIGINTERN PyObject *_wrap_Mat_isContinuous(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Mat *arg1 = (cv::Mat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
bool result;
if (!PyArg_ParseTuple(args,(char *)"O:Mat_isContinuous",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__Mat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mat_isContinuous" "', argument " "1"" of type '" "cv::Mat const *""'");
}
arg1 = reinterpret_cast< cv::Mat * >(argp1);
result = (bool)((cv::Mat const *)arg1)->isContinuous();
resultobj = SWIG_From_bool(static_cast< bool >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Mat_isSubmatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Mat *arg1 = (cv::Mat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
bool result;
if (!PyArg_ParseTuple(args,(char *)"O:Mat_isSubmatrix",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__Mat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mat_isSubmatrix" "', argument " "1"" of type '" "cv::Mat const *""'");
}
arg1 = reinterpret_cast< cv::Mat * >(argp1);
result = (bool)((cv::Mat const *)arg1)->isSubmatrix();
resultobj = SWIG_From_bool(static_cast< bool >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Mat_elemSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Mat *arg1 = (cv::Mat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
size_t result;
if (!PyArg_ParseTuple(args,(char *)"O:Mat_elemSize",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__Mat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mat_elemSize" "', argument " "1"" of type '" "cv::Mat const *""'");
}
arg1 = reinterpret_cast< cv::Mat * >(argp1);
result = ((cv::Mat const *)arg1)->elemSize();
resultobj = SWIG_From_size_t(static_cast< size_t >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Mat_elemSize1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Mat *arg1 = (cv::Mat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
size_t result;
if (!PyArg_ParseTuple(args,(char *)"O:Mat_elemSize1",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__Mat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mat_elemSize1" "', argument " "1"" of type '" "cv::Mat const *""'");
}
arg1 = reinterpret_cast< cv::Mat * >(argp1);
result = ((cv::Mat const *)arg1)->elemSize1();
resultobj = SWIG_From_size_t(static_cast< size_t >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Mat_type(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Mat *arg1 = (cv::Mat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:Mat_type",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__Mat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mat_type" "', argument " "1"" of type '" "cv::Mat const *""'");
}
arg1 = reinterpret_cast< cv::Mat * >(argp1);
result = (int)((cv::Mat const *)arg1)->type();
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Mat_depth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Mat *arg1 = (cv::Mat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:Mat_depth",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__Mat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mat_depth" "', argument " "1"" of type '" "cv::Mat const *""'");
}
arg1 = reinterpret_cast< cv::Mat * >(argp1);
result = (int)((cv::Mat const *)arg1)->depth();
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Mat_channels(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Mat *arg1 = (cv::Mat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:Mat_channels",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__Mat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mat_channels" "', argument " "1"" of type '" "cv::Mat const *""'");
}
arg1 = reinterpret_cast< cv::Mat * >(argp1);
result = (int)((cv::Mat const *)arg1)->channels();
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Mat_step1__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Mat *arg1 = (cv::Mat *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
size_t result;
if (!PyArg_ParseTuple(args,(char *)"OO:Mat_step1",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__Mat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mat_step1" "', argument " "1"" of type '" "cv::Mat const *""'");
}
arg1 = reinterpret_cast< cv::Mat * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Mat_step1" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
result = ((cv::Mat const *)arg1)->step1(arg2);
resultobj = SWIG_From_size_t(static_cast< size_t >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Mat_step1__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Mat *arg1 = (cv::Mat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
size_t result;
if (!PyArg_ParseTuple(args,(char *)"O:Mat_step1",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__Mat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mat_step1" "', argument " "1"" of type '" "cv::Mat const *""'");
}
arg1 = reinterpret_cast< cv::Mat * >(argp1);
result = ((cv::Mat const *)arg1)->step1();
resultobj = SWIG_From_size_t(static_cast< size_t >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Mat_step1(PyObject *self, PyObject *args) {
Py_ssize_t argc;
PyObject *argv[3] = {
0
};
Py_ssize_t ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = args ? PyObject_Length(args) : 0;
for (ii = 0; (ii < 2) && (ii < argc); 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_cv__Mat, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_Mat_step1__SWIG_1(self, args);
}
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cv__Mat, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_Mat_step1__SWIG_0(self, args);
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Mat_step1'.\n"
" Possible C/C++ prototypes are:\n"
" cv::Mat::step1(int) const\n"
" cv::Mat::step1() const\n");
return 0;
}
SWIGINTERN PyObject *_wrap_Mat_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Mat *arg1 = (cv::Mat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
bool result;
if (!PyArg_ParseTuple(args,(char *)"O:Mat_empty",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__Mat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mat_empty" "', argument " "1"" of type '" "cv::Mat const *""'");
}
arg1 = reinterpret_cast< cv::Mat * >(argp1);
result = (bool)((cv::Mat const *)arg1)->empty();
resultobj = SWIG_From_bool(static_cast< bool >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Mat_total(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Mat *arg1 = (cv::Mat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
size_t result;
if (!PyArg_ParseTuple(args,(char *)"O:Mat_total",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__Mat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mat_total" "', argument " "1"" of type '" "cv::Mat const *""'");
}
arg1 = reinterpret_cast< cv::Mat * >(argp1);
result = ((cv::Mat const *)arg1)->total();
resultobj = SWIG_From_size_t(static_cast< size_t >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Mat_checkVector__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Mat *arg1 = (cv::Mat *) 0 ;
int arg2 ;
int arg3 ;
bool arg4 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
bool val4 ;
int ecode4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"OOOO:Mat_checkVector",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__Mat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mat_checkVector" "', argument " "1"" of type '" "cv::Mat const *""'");
}
arg1 = reinterpret_cast< cv::Mat * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Mat_checkVector" "', 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 '" "Mat_checkVector" "', 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 '" "Mat_checkVector" "', argument " "4"" of type '" "bool""'");
}
arg4 = static_cast< bool >(val4);
result = (int)((cv::Mat const *)arg1)->checkVector(arg2,arg3,arg4);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Mat_checkVector__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Mat *arg1 = (cv::Mat *) 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 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"OOO:Mat_checkVector",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__Mat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mat_checkVector" "', argument " "1"" of type '" "cv::Mat const *""'");
}
arg1 = reinterpret_cast< cv::Mat * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Mat_checkVector" "', 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 '" "Mat_checkVector" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
result = (int)((cv::Mat const *)arg1)->checkVector(arg2,arg3);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Mat_checkVector__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Mat *arg1 = (cv::Mat *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"OO:Mat_checkVector",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__Mat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mat_checkVector" "', argument " "1"" of type '" "cv::Mat const *""'");
}
arg1 = reinterpret_cast< cv::Mat * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Mat_checkVector" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
result = (int)((cv::Mat const *)arg1)->checkVector(arg2);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Mat_checkVector(PyObject *self, PyObject *args) {
Py_ssize_t argc;
PyObject *argv[5] = {
0
};
Py_ssize_t ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = args ? PyObject_Length(args) : 0;
for (ii = 0; (ii < 4) && (ii < argc); 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_cv__Mat, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_Mat_checkVector__SWIG_2(self, args);
}
}
}
if (argc == 3) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cv__Mat, 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_Mat_checkVector__SWIG_1(self, args);
}
}
}
}
if (argc == 4) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cv__Mat, 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_bool(argv[3], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_Mat_checkVector__SWIG_0(self, args);
}
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Mat_checkVector'.\n"
" Possible C/C++ prototypes are:\n"
" cv::Mat::checkVector(int,int,bool) const\n"
" cv::Mat::checkVector(int,int) const\n"
" cv::Mat::checkVector(int) const\n");
return 0;
}
SWIGINTERN PyObject *_wrap_Mat_ptr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Mat *arg1 = (cv::Mat *) 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:Mat_ptr",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__Mat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mat_ptr" "', argument " "1"" of type '" "cv::Mat *""'");
}
arg1 = reinterpret_cast< cv::Mat * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Mat_ptr" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
result = (uchar *)(arg1)->ptr(arg2);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_uchar, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Mat_ptr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Mat *arg1 = (cv::Mat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
uchar *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:Mat_ptr",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__Mat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mat_ptr" "', argument " "1"" of type '" "cv::Mat *""'");
}
arg1 = reinterpret_cast< cv::Mat * >(argp1);
result = (uchar *)(arg1)->ptr();
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_uchar, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Mat_ptr__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Mat *arg1 = (cv::Mat *) 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:Mat_ptr",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__Mat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mat_ptr" "', argument " "1"" of type '" "cv::Mat const *""'");
}
arg1 = reinterpret_cast< cv::Mat * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Mat_ptr" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
result = (uchar *)((cv::Mat const *)arg1)->ptr(arg2);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_uchar, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Mat_ptr__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Mat *arg1 = (cv::Mat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
uchar *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:Mat_ptr",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__Mat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mat_ptr" "', argument " "1"" of type '" "cv::Mat const *""'");
}
arg1 = reinterpret_cast< cv::Mat * >(argp1);
result = (uchar *)((cv::Mat const *)arg1)->ptr();
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_uchar, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Mat_ptr__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Mat *arg1 = (cv::Mat *) 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 ;
uchar *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:Mat_ptr",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__Mat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mat_ptr" "', argument " "1"" of type '" "cv::Mat *""'");
}
arg1 = reinterpret_cast< cv::Mat * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Mat_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 '" "Mat_ptr" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
result = (uchar *)(arg1)->ptr(arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_uchar, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Mat_ptr__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Mat *arg1 = (cv::Mat *) 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 ;
uchar *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:Mat_ptr",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__Mat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mat_ptr" "', argument " "1"" of type '" "cv::Mat const *""'");
}
arg1 = reinterpret_cast< cv::Mat * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Mat_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 '" "Mat_ptr" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
result = (uchar *)((cv::Mat const *)arg1)->ptr(arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_uchar, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Mat_ptr__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Mat *arg1 = (cv::Mat *) 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 ;
uchar *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOO:Mat_ptr",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__Mat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mat_ptr" "', argument " "1"" of type '" "cv::Mat *""'");
}
arg1 = reinterpret_cast< cv::Mat * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Mat_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 '" "Mat_ptr" "', 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 '" "Mat_ptr" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
result = (uchar *)(arg1)->ptr(arg2,arg3,arg4);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_uchar, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Mat_ptr__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Mat *arg1 = (cv::Mat *) 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 ;
uchar *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOO:Mat_ptr",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__Mat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mat_ptr" "', argument " "1"" of type '" "cv::Mat const *""'");
}
arg1 = reinterpret_cast< cv::Mat * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Mat_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 '" "Mat_ptr" "', 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 '" "Mat_ptr" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
result = (uchar *)((cv::Mat const *)arg1)->ptr(arg2,arg3,arg4);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_uchar, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Mat_ptr__SWIG_8(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Mat *arg1 = (cv::Mat *) 0 ;
int *arg2 = (int *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
uchar *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:Mat_ptr",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__Mat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mat_ptr" "', argument " "1"" of type '" "cv::Mat *""'");
}
arg1 = reinterpret_cast< cv::Mat * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_int, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mat_ptr" "', argument " "2"" of type '" "int const *""'");
}
arg2 = reinterpret_cast< int * >(argp2);
result = (uchar *)(arg1)->ptr((int const *)arg2);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_uchar, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Mat_ptr__SWIG_9(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Mat *arg1 = (cv::Mat *) 0 ;
int *arg2 = (int *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
uchar *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:Mat_ptr",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__Mat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mat_ptr" "', argument " "1"" of type '" "cv::Mat const *""'");
}
arg1 = reinterpret_cast< cv::Mat * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_int, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mat_ptr" "', argument " "2"" of type '" "int const *""'");
}
arg2 = reinterpret_cast< int * >(argp2);
result = (uchar *)((cv::Mat const *)arg1)->ptr((int const *)arg2);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_uchar, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Mat_ptr(PyObject *self, PyObject *args) {
Py_ssize_t argc;
PyObject *argv[5] = {
0
};
Py_ssize_t ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = args ? PyObject_Length(args) : 0;
for (ii = 0; (ii < 4) && (ii < argc); 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_cv__Mat, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_Mat_ptr__SWIG_1(self, args);
}
}
if (argc == 1) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cv__Mat, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_Mat_ptr__SWIG_3(self, args);
}
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cv__Mat, 0);
_v = SWIG_CheckState(res);
if (_v) {
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_int, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_Mat_ptr__SWIG_8(self, args);
}
}
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cv__Mat, 0);
_v = SWIG_CheckState(res);
if (_v) {
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_int, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_Mat_ptr__SWIG_9(self, args);
}
}
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cv__Mat, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_Mat_ptr__SWIG_0(self, args);
}
}
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cv__Mat, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_Mat_ptr__SWIG_2(self, args);
}
}
}
if (argc == 3) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cv__Mat, 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_Mat_ptr__SWIG_4(self, args);
}
}
}
}
if (argc == 3) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cv__Mat, 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_Mat_ptr__SWIG_5(self, args);
}
}
}
}
if (argc == 4) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cv__Mat, 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) {
return _wrap_Mat_ptr__SWIG_6(self, args);
}
}
}
}
}
if (argc == 4) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_cv__Mat, 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) {
return _wrap_Mat_ptr__SWIG_7(self, args);
}
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Mat_ptr'.\n"
" Possible C/C++ prototypes are:\n"
" cv::Mat::ptr(int)\n"
" cv::Mat::ptr()\n"
" cv::Mat::ptr(int) const\n"
" cv::Mat::ptr() const\n"
" cv::Mat::ptr(int,int)\n"
" cv::Mat::ptr(int,int) const\n"
" cv::Mat::ptr(int,int,int)\n"
" cv::Mat::ptr(int,int,int) const\n"
" cv::Mat::ptr(int const *)\n"
" cv::Mat::ptr(int const *) const\n");
return 0;
}
SWIGINTERN PyObject *_wrap_Mat_flags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Mat *arg1 = (cv::Mat *) 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:Mat_flags_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__Mat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mat_flags_set" "', argument " "1"" of type '" "cv::Mat *""'");
}
arg1 = reinterpret_cast< cv::Mat * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Mat_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_Mat_flags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Mat *arg1 = (cv::Mat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:Mat_flags_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__Mat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mat_flags_get" "', argument " "1"" of type '" "cv::Mat *""'");
}
arg1 = reinterpret_cast< cv::Mat * >(argp1);
result = (int) ((arg1)->flags);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Mat_dims_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Mat *arg1 = (cv::Mat *) 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:Mat_dims_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__Mat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mat_dims_set" "', argument " "1"" of type '" "cv::Mat *""'");
}
arg1 = reinterpret_cast< cv::Mat * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Mat_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_Mat_dims_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Mat *arg1 = (cv::Mat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:Mat_dims_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__Mat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mat_dims_get" "', argument " "1"" of type '" "cv::Mat *""'");
}
arg1 = reinterpret_cast< cv::Mat * >(argp1);
result = (int) ((arg1)->dims);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Mat_rows_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Mat *arg1 = (cv::Mat *) 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:Mat_rows_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__Mat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mat_rows_set" "', argument " "1"" of type '" "cv::Mat *""'");
}
arg1 = reinterpret_cast< cv::Mat * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Mat_rows_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->rows = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Mat_rows_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Mat *arg1 = (cv::Mat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:Mat_rows_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__Mat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mat_rows_get" "', argument " "1"" of type '" "cv::Mat *""'");
}
arg1 = reinterpret_cast< cv::Mat * >(argp1);
result = (int) ((arg1)->rows);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Mat_cols_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Mat *arg1 = (cv::Mat *) 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:Mat_cols_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__Mat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mat_cols_set" "', argument " "1"" of type '" "cv::Mat *""'");
}
arg1 = reinterpret_cast< cv::Mat * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Mat_cols_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->cols = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Mat_cols_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Mat *arg1 = (cv::Mat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:Mat_cols_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__Mat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mat_cols_get" "', argument " "1"" of type '" "cv::Mat *""'");
}
arg1 = reinterpret_cast< cv::Mat * >(argp1);
result = (int) ((arg1)->cols);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Mat_data_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Mat *arg1 = (cv::Mat *) 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:Mat_data_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__Mat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mat_data_set" "', argument " "1"" of type '" "cv::Mat *""'");
}
arg1 = reinterpret_cast< cv::Mat * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_uchar, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mat_data_set" "', argument " "2"" of type '" "uchar *""'");
}
arg2 = reinterpret_cast< uchar * >(argp2);
if (arg1) (arg1)->data = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Mat_data_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Mat *arg1 = (cv::Mat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
uchar *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:Mat_data_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__Mat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mat_data_get" "', argument " "1"" of type '" "cv::Mat *""'");
}
arg1 = reinterpret_cast< cv::Mat * >(argp1);
result = (uchar *) ((arg1)->data);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_uchar, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Mat_datastart_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Mat *arg1 = (cv::Mat *) 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:Mat_datastart_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__Mat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mat_datastart_set" "', argument " "1"" of type '" "cv::Mat *""'");
}
arg1 = reinterpret_cast< cv::Mat * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_uchar, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mat_datastart_set" "', argument " "2"" of type '" "uchar const *""'");
}
arg2 = reinterpret_cast< uchar * >(argp2);
if (arg1) (arg1)->datastart = (uchar const *)arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Mat_datastart_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Mat *arg1 = (cv::Mat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
uchar *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:Mat_datastart_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__Mat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mat_datastart_get" "', argument " "1"" of type '" "cv::Mat *""'");
}
arg1 = reinterpret_cast< cv::Mat * >(argp1);
result = (uchar *) ((arg1)->datastart);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_uchar, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Mat_dataend_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Mat *arg1 = (cv::Mat *) 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:Mat_dataend_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__Mat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mat_dataend_set" "', argument " "1"" of type '" "cv::Mat *""'");
}
arg1 = reinterpret_cast< cv::Mat * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_uchar, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mat_dataend_set" "', argument " "2"" of type '" "uchar const *""'");
}
arg2 = reinterpret_cast< uchar * >(argp2);
if (arg1) (arg1)->dataend = (uchar const *)arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Mat_dataend_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Mat *arg1 = (cv::Mat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
uchar *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:Mat_dataend_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__Mat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mat_dataend_get" "', argument " "1"" of type '" "cv::Mat *""'");
}
arg1 = reinterpret_cast< cv::Mat * >(argp1);
result = (uchar *) ((arg1)->dataend);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_uchar, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Mat_datalimit_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Mat *arg1 = (cv::Mat *) 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:Mat_datalimit_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__Mat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mat_datalimit_set" "', argument " "1"" of type '" "cv::Mat *""'");
}
arg1 = reinterpret_cast< cv::Mat * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_uchar, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mat_datalimit_set" "', argument " "2"" of type '" "uchar const *""'");
}
arg2 = reinterpret_cast< uchar * >(argp2);
if (arg1) (arg1)->datalimit = (uchar const *)arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Mat_datalimit_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Mat *arg1 = (cv::Mat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
uchar *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:Mat_datalimit_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__Mat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mat_datalimit_get" "', argument " "1"" of type '" "cv::Mat *""'");
}
arg1 = reinterpret_cast< cv::Mat * >(argp1);
result = (uchar *) ((arg1)->datalimit);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_uchar, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_Mat__SWIG_28(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
int arg3 ;
ptrdiff_t arg4 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
ptrdiff_t val4 ;
int ecode4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
cv::Mat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOO:new_Mat",&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_Mat" "', 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_Mat" "', 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_Mat" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
ecode4 = SWIG_AsVal_ptrdiff_t(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Mat" "', argument " "4"" of type '" "ptrdiff_t""'");
}
arg4 = static_cast< ptrdiff_t >(val4);
result = (cv::Mat *)new_cv_Mat__SWIG_28(arg1,arg2,arg3,arg4);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__Mat, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_Mat(PyObject *self, PyObject *args) {
Py_ssize_t argc;
PyObject *argv[6] = {
0
};
Py_ssize_t ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = args ? PyObject_Length(args) : 0;
for (ii = 0; (ii < 5) && (ii < argc); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 0) {
return _wrap_new_Mat__SWIG_0(self, args);
}
if (argc == 1) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__Mat, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new_Mat__SWIG_7(self, args);
}
}
if (argc == 2) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__Size_T_int_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_new_Mat__SWIG_2(self, args);
}
}
}
if (argc == 2) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__Mat, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__Range, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new_Mat__SWIG_15(self, args);
}
}
}
if (argc == 2) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__Mat, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__Rect_T_int_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new_Mat__SWIG_16(self, args);
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__Size_T_int_t, 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_cv__Scalar_T_double_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new_Mat__SWIG_4(self, args);
}
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__Mat, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__Range, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Range, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new_Mat__SWIG_14(self, args);
}
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__Size_T_int_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
void *ptr = 0;
int res = SWIG_ConvertPtr(argv[2], &ptr, 0, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new_Mat__SWIG_11(self, args);
}
}
}
}
if (argc == 3) {
int _v;
{
int res = SWIG_AsVal_int(argv[0], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_int, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_new_Mat__SWIG_5(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_Mat__SWIG_1(self, args);
}
}
}
}
if (argc == 4) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__Size_T_int_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
void *ptr = 0;
int res = SWIG_ConvertPtr(argv[2], &ptr, 0, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_size_t(argv[3], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_new_Mat__SWIG_10(self, args);
}
}
}
}
}
if (argc == 4) {
int _v;
{
int res = SWIG_AsVal_int(argv[0], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_int, 0);
_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_cv__Scalar_T_double_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new_Mat__SWIG_6(self, args);
}
}
}
}
}
if (argc == 4) {
int _v;
{
int res = SWIG_AsVal_int(argv[0], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_int, 0);
_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_Mat__SWIG_13(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) {
int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_cv__Scalar_T_double_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new_Mat__SWIG_3(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_Mat__SWIG_9(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) {
{
int res = SWIG_AsVal_ptrdiff_t(argv[3], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_new_Mat__SWIG_28(self, args);
}
}
}
}
}
if (argc == 5) {
int _v;
{
int res = SWIG_AsVal_int(argv[0], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_int, 0);
_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) {
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_size_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new_Mat__SWIG_12(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_size_t(argv[4], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_new_Mat__SWIG_8(self, args);
}
}
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Mat'.\n"
" Possible C/C++ prototypes are:\n"
" cv::Mat::Mat()\n"
" cv::Mat::Mat(int,int,int)\n"
" cv::Mat::Mat(cv::Size,int)\n"
" cv::Mat::Mat(int,int,int,cv::Scalar const &)\n"
" cv::Mat::Mat(cv::Size,int,cv::Scalar const &)\n"
" cv::Mat::Mat(int,int const *,int)\n"
" cv::Mat::Mat(int,int const *,int,cv::Scalar const &)\n"
" cv::Mat::Mat(cv::Mat const &)\n"
" cv::Mat::Mat(int,int,int,void *,size_t)\n"
" cv::Mat::Mat(int,int,int,void *)\n"
" cv::Mat::Mat(cv::Size,int,void *,size_t)\n"
" cv::Mat::Mat(cv::Size,int,void *)\n"
" cv::Mat::Mat(int,int const *,int,void *,size_t const *)\n"
" cv::Mat::Mat(int,int const *,int,void *)\n"
" cv::Mat::Mat(cv::Mat const &,cv::Range const &,cv::Range const &)\n"
" cv::Mat::Mat(cv::Mat const &,cv::Range const &)\n"
" cv::Mat::Mat(cv::Mat const &,cv::Rect const &)\n"
" cv::Mat::Mat(int,int,int,ptrdiff_t)\n");
return 0;
}
SWIGINTERN PyObject *_wrap_Mat___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Mat *arg1 = (cv::Mat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
std::string result;
if (!PyArg_ParseTuple(args,(char *)"O:Mat___str__",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__Mat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mat___str__" "', argument " "1"" of type '" "cv::Mat *""'");
}
arg1 = reinterpret_cast< cv::Mat * >(argp1);
result = cv_Mat___str__(arg1);
resultobj = SWIG_From_std_string(static_cast< std::string >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *Mat_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_cv__Mat, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_new__cv_numpy_sizeof_uint8_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::_SizeOf< uint8_t > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new__cv_numpy_sizeof_uint8_t")) SWIG_fail;
result = (cv::_SizeOf< uint8_t > *)new cv::_SizeOf< uint8_t >();
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv___SizeOfT_unsigned_char_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete__cv_numpy_sizeof_uint8_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::_SizeOf< uint8_t > *arg1 = (cv::_SizeOf< uint8_t > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete__cv_numpy_sizeof_uint8_t",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv___SizeOfT_unsigned_char_t, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__cv_numpy_sizeof_uint8_t" "', argument " "1"" of type '" "cv::_SizeOf< uint8_t > *""'");
}
arg1 = reinterpret_cast< cv::_SizeOf< uint8_t > * >(argp1);
delete arg1;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_cv_numpy_sizeof_uint8_t_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_cv___SizeOfT_unsigned_char_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap__uint8_tArray_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< uint8_t > *arg1 = (std::vector< uint8_t > *) 0 ;
PyObject **arg2 = (PyObject **) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
swig::SwigPyIterator *result = 0 ;
arg2 = &obj0;
if (!PyArg_ParseTuple(args,(char *)"O:_uint8_tArray_iterator",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_uint8_tArray_iterator" "', argument " "1"" of type '" "std::vector< uint8_t > *""'");
}
arg1 = reinterpret_cast< std::vector< uint8_t > * >(argp1);
result = (swig::SwigPyIterator *)std_vector_Sl_uint8_t_Sg__iterator(arg1,arg2);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__uint8_tArray___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< uint8_t > *arg1 = (std::vector< uint8_t > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
bool result;
if (!PyArg_ParseTuple(args,(char *)"O:_uint8_tArray___nonzero__",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_uint8_tArray___nonzero__" "', argument " "1"" of type '" "std::vector< uint8_t > const *""'");
}
arg1 = reinterpret_cast< std::vector< uint8_t > * >(argp1);
result = (bool)std_vector_Sl_uint8_t_Sg____nonzero__((std::vector< unsigned char > const *)arg1);
resultobj = SWIG_From_bool(static_cast< bool >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__uint8_tArray___bool__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< uint8_t > *arg1 = (std::vector< uint8_t > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
bool result;
if (!PyArg_ParseTuple(args,(char *)"O:_uint8_tArray___bool__",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_uint8_tArray___bool__" "', argument " "1"" of type '" "std::vector< uint8_t > const *""'");
}
arg1 = reinterpret_cast< std::vector< uint8_t > * >(argp1);
result = (bool)std_vector_Sl_uint8_t_Sg____bool__((std::vector< unsigned char > const *)arg1);
resultobj = SWIG_From_bool(static_cast< bool >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__uint8_tArray___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< uint8_t > *arg1 = (std::vector< uint8_t > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
std::vector< unsigned char >::size_type result;
if (!PyArg_ParseTuple(args,(char *)"O:_uint8_tArray___len__",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_uint8_tArray___len__" "', argument " "1"" of type '" "std::vector< uint8_t > const *""'");
}
arg1 = reinterpret_cast< std::vector< uint8_t > * >(argp1);
result = std_vector_Sl_uint8_t_Sg____len__((std::vector< unsigned char > const *)arg1);
resultobj = SWIG_From_size_t(static_cast< size_t >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__uint8_tArray___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< uint8_t > *arg1 = (std::vector< uint8_t > *) 0 ;
std::vector< unsigned char >::difference_type arg2 ;
std::vector< unsigned char >::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< unsigned char,std::allocator< unsigned char > > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:_uint8_tArray___getslice__",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_uint8_tArray___getslice__" "', argument " "1"" of type '" "std::vector< uint8_t > *""'");
}
arg1 = reinterpret_cast< std::vector< uint8_t > * >(argp1);
ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_uint8_tArray___getslice__" "', argument " "2"" of type '" "std::vector< unsigned char >::difference_type""'");
}
arg2 = static_cast< std::vector< unsigned char >::difference_type >(val2);
ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "_uint8_tArray___getslice__" "', argument " "3"" of type '" "std::vector< unsigned char >::difference_type""'");
}
arg3 = static_cast< std::vector< unsigned char >::difference_type >(val3);
try {
result = (std::vector< unsigned char,std::allocator< unsigned char > > *)std_vector_Sl_uint8_t_Sg____getslice__(arg1,arg2,arg3);
}
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_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__uint8_tArray___setslice____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< uint8_t > *arg1 = (std::vector< uint8_t > *) 0 ;
std::vector< unsigned char >::difference_type arg2 ;
std::vector< unsigned char >::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:_uint8_tArray___setslice__",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_uint8_tArray___setslice__" "', argument " "1"" of type '" "std::vector< uint8_t > *""'");
}
arg1 = reinterpret_cast< std::vector< uint8_t > * >(argp1);
ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_uint8_tArray___setslice__" "', argument " "2"" of type '" "std::vector< unsigned char >::difference_type""'");
}
arg2 = static_cast< std::vector< unsigned char >::difference_type >(val2);
ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "_uint8_tArray___setslice__" "', argument " "3"" of type '" "std::vector< unsigned char >::difference_type""'");
}
arg3 = static_cast< std::vector< unsigned char >::difference_type >(val3);
try {
std_vector_Sl_uint8_t_Sg____setslice____SWIG_0(arg1,arg2,arg3);
}
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();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__uint8_tArray___setslice____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< uint8_t > *arg1 = (std::vector< uint8_t > *) 0 ;
std::vector< unsigned char >::difference_type arg2 ;
std::vector< unsigned char >::difference_type arg3 ;
std::vector< unsigned char,std::allocator< unsigned char > > *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:_uint8_tArray___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_uint8_tArray___setslice__" "', argument " "1"" of type '" "std::vector< uint8_t > *""'");
}
arg1 = reinterpret_cast< std::vector< uint8_t > * >(argp1);
ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_uint8_tArray___setslice__" "', argument " "2"" of type '" "std::vector< unsigned char >::difference_type""'");
}
arg2 = static_cast< std::vector< unsigned char >::difference_type >(val2);
ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "_uint8_tArray___setslice__" "', argument " "3"" of type '" "std::vector< unsigned char >::difference_type""'");
}
arg3 = static_cast< std::vector< unsigned char >::difference_type >(val3);
{
std::vector< unsigned char,std::allocator< unsigned char > > *ptr = (std::vector< unsigned char,std::allocator< unsigned char > > *)0;
res4 = swig::asptr(obj3, &ptr);
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "_uint8_tArray___setslice__" "', argument " "4"" of type '" "std::vector< unsigned char,std::allocator< unsigned char > > const &""'");
}
if (!ptr) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_uint8_tArray___setslice__" "', argument " "4"" of type '" "std::vector< unsigned char,std::allocator< unsigned char > > const &""'");
}
arg4 = ptr;
}
try {
std_vector_Sl_uint8_t_Sg____setslice____SWIG_1(arg1,arg2,arg3,(std::vector< unsigned char,std::allocator< unsigned char > > 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__uint8_tArray___setslice__(PyObject *self, PyObject *args) {
Py_ssize_t argc;
PyObject *argv[5] = {
0
};
Py_ssize_t ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = args ? PyObject_Length(args) : 0;
for (ii = 0; (ii < 4) && (ii < argc); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 3) {
int _v;
int res = swig::asptr(argv[0], (std::vector< unsigned char,std::allocator< unsigned char > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap__uint8_tArray___setslice____SWIG_0(self, args);
}
}
}
}
if (argc == 4) {
int _v;
int res = swig::asptr(argv[0], (std::vector< unsigned char,std::allocator< unsigned char > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
int res = swig::asptr(argv[3], (std::vector< unsigned char,std::allocator< unsigned char > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
return _wrap__uint8_tArray___setslice____SWIG_1(self, args);
}
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function '_uint8_tArray___setslice__'.\n"
" Possible C/C++ prototypes are:\n"
" std::vector< uint8_t >::__setslice__(std::vector< unsigned char >::difference_type,std::vector< unsigned char >::difference_type)\n"
" std::vector< uint8_t >::__setslice__(std::vector< unsigned char >::difference_type,std::vector< unsigned char >::difference_type,std::vector< unsigned char,std::allocator< unsigned char > > const &)\n");
return 0;
}
SWIGINTERN PyObject *_wrap__uint8_tArray___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< uint8_t > *arg1 = (std::vector< uint8_t > *) 0 ;
std::vector< unsigned char >::difference_type arg2 ;
std::vector< unsigned char >::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:_uint8_tArray___delslice__",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_uint8_tArray___delslice__" "', argument " "1"" of type '" "std::vector< uint8_t > *""'");
}
arg1 = reinterpret_cast< std::vector< uint8_t > * >(argp1);
ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_uint8_tArray___delslice__" "', argument " "2"" of type '" "std::vector< unsigned char >::difference_type""'");
}
arg2 = static_cast< std::vector< unsigned char >::difference_type >(val2);
ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "_uint8_tArray___delslice__" "', argument " "3"" of type '" "std::vector< unsigned char >::difference_type""'");
}
arg3 = static_cast< std::vector< unsigned char >::difference_type >(val3);
try {
std_vector_Sl_uint8_t_Sg____delslice__(arg1,arg2,arg3);
}
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();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__uint8_tArray___delitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< uint8_t > *arg1 = (std::vector< uint8_t > *) 0 ;
std::vector< unsigned char >::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:_uint8_tArray___delitem__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_uint8_tArray___delitem__" "', argument " "1"" of type '" "std::vector< uint8_t > *""'");
}
arg1 = reinterpret_cast< std::vector< uint8_t > * >(argp1);
ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_uint8_tArray___delitem__" "', argument " "2"" of type '" "std::vector< unsigned char >::difference_type""'");
}
arg2 = static_cast< std::vector< unsigned char >::difference_type >(val2);
try {
std_vector_Sl_uint8_t_Sg____delitem____SWIG_0(arg1,arg2);
}
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();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__uint8_tArray___getitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< uint8_t > *arg1 = (std::vector< uint8_t > *) 0 ;
PySliceObject *arg2 = (PySliceObject *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
std::vector< unsigned char,std::allocator< unsigned char > > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:_uint8_tArray___getitem__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_uint8_tArray___getitem__" "', argument " "1"" of type '" "std::vector< uint8_t > *""'");
}
arg1 = reinterpret_cast< std::vector< uint8_t > * >(argp1);
{
if (!PySlice_Check(obj1)) {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "_uint8_tArray___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
arg2 = (PySliceObject *) obj1;
}
try {
result = (std::vector< unsigned char,std::allocator< unsigned char > > *)std_vector_Sl_uint8_t_Sg____getitem____SWIG_0(arg1,arg2);
}
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_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__uint8_tArray___setitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< uint8_t > *arg1 = (std::vector< uint8_t > *) 0 ;
PySliceObject *arg2 = (PySliceObject *) 0 ;
std::vector< unsigned char,std::allocator< unsigned char > > *arg3 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res3 = SWIG_OLDOBJ ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:_uint8_tArray___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_uint8_tArray___setitem__" "', argument " "1"" of type '" "std::vector< uint8_t > *""'");
}
arg1 = reinterpret_cast< std::vector< uint8_t > * >(argp1);
{
if (!PySlice_Check(obj1)) {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "_uint8_tArray___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
arg2 = (PySliceObject *) obj1;
}
{
std::vector< unsigned char,std::allocator< unsigned char > > *ptr = (std::vector< unsigned char,std::allocator< unsigned char > > *)0;
res3 = swig::asptr(obj2, &ptr);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "_uint8_tArray___setitem__" "', argument " "3"" of type '" "std::vector< unsigned char,std::allocator< unsigned char > > const &""'");
}
if (!ptr) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_uint8_tArray___setitem__" "', argument " "3"" of type '" "std::vector< unsigned char,std::allocator< unsigned char > > const &""'");
}
arg3 = ptr;
}
try {
std_vector_Sl_uint8_t_Sg____setitem____SWIG_0(arg1,arg2,(std::vector< unsigned char,std::allocator< unsigned char > > const &)*arg3);
}
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(res3)) delete arg3;
return resultobj;
fail:
if (SWIG_IsNewObj(res3)) delete arg3;
return NULL;
}
SWIGINTERN PyObject *_wrap__uint8_tArray___setitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< uint8_t > *arg1 = (std::vector< uint8_t > *) 0 ;
PySliceObject *arg2 = (PySliceObject *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:_uint8_tArray___setitem__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_uint8_tArray___setitem__" "', argument " "1"" of type '" "std::vector< uint8_t > *""'");
}
arg1 = reinterpret_cast< std::vector< uint8_t > * >(argp1);
{
if (!PySlice_Check(obj1)) {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "_uint8_tArray___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
arg2 = (PySliceObject *) obj1;
}
try {
std_vector_Sl_uint8_t_Sg____setitem____SWIG_1(arg1,arg2);
}
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();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__uint8_tArray___delitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< uint8_t > *arg1 = (std::vector< uint8_t > *) 0 ;
PySliceObject *arg2 = (PySliceObject *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:_uint8_tArray___delitem__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_uint8_tArray___delitem__" "', argument " "1"" of type '" "std::vector< uint8_t > *""'");
}
arg1 = reinterpret_cast< std::vector< uint8_t > * >(argp1);
{
if (!PySlice_Check(obj1)) {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "_uint8_tArray___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
arg2 = (PySliceObject *) obj1;
}
try {
std_vector_Sl_uint8_t_Sg____delitem____SWIG_1(arg1,arg2);
}
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();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__uint8_tArray___delitem__(PyObject *self, PyObject *args) {
Py_ssize_t argc;
PyObject *argv[3] = {
0
};
Py_ssize_t ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = args ? PyObject_Length(args) : 0;
for (ii = 0; (ii < 2) && (ii < argc); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 2) {
int _v;
int res = swig::asptr(argv[0], (std::vector< unsigned char,std::allocator< unsigned char > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
{
_v = PySlice_Check(argv[1]);
}
if (_v) {
return _wrap__uint8_tArray___delitem____SWIG_1(self, args);
}
}
}
if (argc == 2) {
int _v;
int res = swig::asptr(argv[0], (std::vector< unsigned char,std::allocator< unsigned char > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap__uint8_tArray___delitem____SWIG_0(self, args);
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function '_uint8_tArray___delitem__'.\n"
" Possible C/C++ prototypes are:\n"
" std::vector< uint8_t >::__delitem__(std::vector< unsigned char >::difference_type)\n"
" std::vector< uint8_t >::__delitem__(PySliceObject *)\n");
return 0;
}
SWIGINTERN PyObject *_wrap__uint8_tArray___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< uint8_t > *arg1 = (std::vector< uint8_t > *) 0 ;
std::vector< unsigned char >::difference_type arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
ptrdiff_t val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
std::vector< unsigned char >::value_type *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:_uint8_tArray___getitem__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_uint8_tArray___getitem__" "', argument " "1"" of type '" "std::vector< uint8_t > const *""'");
}
arg1 = reinterpret_cast< std::vector< uint8_t > * >(argp1);
ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_uint8_tArray___getitem__" "', argument " "2"" of type '" "std::vector< unsigned char >::difference_type""'");
}
arg2 = static_cast< std::vector< unsigned char >::difference_type >(val2);
try {
result = (std::vector< unsigned char >::value_type *) &std_vector_Sl_uint8_t_Sg____getitem____SWIG_1((std::vector< unsigned char > const *)arg1,arg2);
}
catch(std::out_of_range &_e) {
SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
}
resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(*result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__uint8_tArray___getitem__(PyObject *self, PyObject *args) {
Py_ssize_t argc;
PyObject *argv[3] = {
0
};
Py_ssize_t ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = args ? PyObject_Length(args) : 0;
for (ii = 0; (ii < 2) && (ii < argc); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 2) {
int _v;
int res = swig::asptr(argv[0], (std::vector< unsigned char,std::allocator< unsigned char > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
{
_v = PySlice_Check(argv[1]);
}
if (_v) {
return _wrap__uint8_tArray___getitem____SWIG_0(self, args);
}
}
}
if (argc == 2) {
int _v;
int res = swig::asptr(argv[0], (std::vector< unsigned char,std::allocator< unsigned char > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap__uint8_tArray___getitem____SWIG_1(self, args);
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function '_uint8_tArray___getitem__'.\n"
" Possible C/C++ prototypes are:\n"
" std::vector< uint8_t >::__getitem__(PySliceObject *)\n"
" std::vector< uint8_t >::__getitem__(std::vector< unsigned char >::difference_type) const\n");
return 0;
}
SWIGINTERN PyObject *_wrap__uint8_tArray___setitem____SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< uint8_t > *arg1 = (std::vector< uint8_t > *) 0 ;
std::vector< unsigned char >::difference_type arg2 ;
std::vector< unsigned char >::value_type *arg3 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
ptrdiff_t val2 ;
int ecode2 = 0 ;
std::vector< unsigned char >::value_type temp3 ;
unsigned char val3 ;
int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:_uint8_tArray___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_uint8_tArray___setitem__" "', argument " "1"" of type '" "std::vector< uint8_t > *""'");
}
arg1 = reinterpret_cast< std::vector< uint8_t > * >(argp1);
ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_uint8_tArray___setitem__" "', argument " "2"" of type '" "std::vector< unsigned char >::difference_type""'");
}
arg2 = static_cast< std::vector< unsigned char >::difference_type >(val2);
ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "_uint8_tArray___setitem__" "', argument " "3"" of type '" "std::vector< unsigned char >::value_type""'");
}
temp3 = static_cast< std::vector< unsigned char >::value_type >(val3);
arg3 = &temp3;
try {
std_vector_Sl_uint8_t_Sg____setitem____SWIG_2(arg1,arg2,(unsigned char 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__uint8_tArray___setitem__(PyObject *self, PyObject *args) {
Py_ssize_t argc;
PyObject *argv[4] = {
0
};
Py_ssize_t ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = args ? PyObject_Length(args) : 0;
for (ii = 0; (ii < 3) && (ii < argc); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 2) {
int _v;
int res = swig::asptr(argv[0], (std::vector< unsigned char,std::allocator< unsigned char > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
{
_v = PySlice_Check(argv[1]);
}
if (_v) {
return _wrap__uint8_tArray___setitem____SWIG_1(self, args);
}
}
}
if (argc == 3) {
int _v;
int res = swig::asptr(argv[0], (std::vector< unsigned char,std::allocator< unsigned char > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
{
_v = PySlice_Check(argv[1]);
}
if (_v) {
int res = swig::asptr(argv[2], (std::vector< unsigned char,std::allocator< unsigned char > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
return _wrap__uint8_tArray___setitem____SWIG_0(self, args);
}
}
}
}
if (argc == 3) {
int _v;
int res = swig::asptr(argv[0], (std::vector< unsigned char,std::allocator< unsigned char > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_unsigned_SS_char(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap__uint8_tArray___setitem____SWIG_2(self, args);
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function '_uint8_tArray___setitem__'.\n"
" Possible C/C++ prototypes are:\n"
" std::vector< uint8_t >::__setitem__(PySliceObject *,std::vector< unsigned char,std::allocator< unsigned char > > const &)\n"
" std::vector< uint8_t >::__setitem__(PySliceObject *)\n"
" std::vector< uint8_t >::__setitem__(std::vector< unsigned char >::difference_type,std::vector< unsigned char >::value_type const &)\n");
return 0;
}
SWIGINTERN PyObject *_wrap__uint8_tArray_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< uint8_t > *arg1 = (std::vector< uint8_t > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
std::vector< unsigned char >::value_type result;
if (!PyArg_ParseTuple(args,(char *)"O:_uint8_tArray_pop",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_uint8_tArray_pop" "', argument " "1"" of type '" "std::vector< uint8_t > *""'");
}
arg1 = reinterpret_cast< std::vector< uint8_t > * >(argp1);
try {
result = (std::vector< unsigned char >::value_type)std_vector_Sl_uint8_t_Sg__pop(arg1);
}
catch(std::out_of_range &_e) {
SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
}
resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__uint8_tArray_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< uint8_t > *arg1 = (std::vector< uint8_t > *) 0 ;
std::vector< unsigned char >::value_type *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
std::vector< unsigned char >::value_type temp2 ;
unsigned char val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:_uint8_tArray_append",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_uint8_tArray_append" "', argument " "1"" of type '" "std::vector< uint8_t > *""'");
}
arg1 = reinterpret_cast< std::vector< uint8_t > * >(argp1);
ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_uint8_tArray_append" "', argument " "2"" of type '" "std::vector< unsigned char >::value_type""'");
}
temp2 = static_cast< std::vector< unsigned char >::value_type >(val2);
arg2 = &temp2;
std_vector_Sl_uint8_t_Sg__append(arg1,(unsigned char const &)*arg2);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__uint8_tArray__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< uint8_t > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new__uint8_tArray")) SWIG_fail;
result = (std::vector< uint8_t > *)new std::vector< uint8_t >();
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__uint8_tArray__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< uint8_t > *arg1 = 0 ;
int res1 = SWIG_OLDOBJ ;
PyObject * obj0 = 0 ;
std::vector< uint8_t > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__uint8_tArray",&obj0)) SWIG_fail;
{
std::vector< unsigned char,std::allocator< unsigned char > > *ptr = (std::vector< unsigned char,std::allocator< unsigned char > > *)0;
res1 = swig::asptr(obj0, &ptr);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__uint8_tArray" "', argument " "1"" of type '" "std::vector< uint8_t > const &""'");
}
if (!ptr) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__uint8_tArray" "', argument " "1"" of type '" "std::vector< uint8_t > const &""'");
}
arg1 = ptr;
}
result = (std::vector< uint8_t > *)new std::vector< uint8_t >((std::vector< uint8_t > const &)*arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_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__uint8_tArray_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< uint8_t > *arg1 = (std::vector< uint8_t > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
bool result;
if (!PyArg_ParseTuple(args,(char *)"O:_uint8_tArray_empty",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_uint8_tArray_empty" "', argument " "1"" of type '" "std::vector< uint8_t > const *""'");
}
arg1 = reinterpret_cast< std::vector< uint8_t > * >(argp1);
result = (bool)((std::vector< uint8_t > const *)arg1)->empty();
resultobj = SWIG_From_bool(static_cast< bool >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__uint8_tArray_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< uint8_t > *arg1 = (std::vector< uint8_t > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
std::vector< unsigned char >::size_type result;
if (!PyArg_ParseTuple(args,(char *)"O:_uint8_tArray_size",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_uint8_tArray_size" "', argument " "1"" of type '" "std::vector< uint8_t > const *""'");
}
arg1 = reinterpret_cast< std::vector< uint8_t > * >(argp1);
result = ((std::vector< uint8_t > const *)arg1)->size();
resultobj = SWIG_From_size_t(static_cast< size_t >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__uint8_tArray_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< uint8_t > *arg1 = (std::vector< uint8_t > *) 0 ;
std::vector< uint8_t > *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:_uint8_tArray_swap",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_uint8_tArray_swap" "', argument " "1"" of type '" "std::vector< uint8_t > *""'");
}
arg1 = reinterpret_cast< std::vector< uint8_t > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_uint8_tArray_swap" "', argument " "2"" of type '" "std::vector< uint8_t > &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_uint8_tArray_swap" "', argument " "2"" of type '" "std::vector< uint8_t > &""'");
}
arg2 = reinterpret_cast< std::vector< uint8_t > * >(argp2);
(arg1)->swap(*arg2);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__uint8_tArray_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< uint8_t > *arg1 = (std::vector< uint8_t > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
SwigValueWrapper< std::vector< unsigned char >::iterator > result;
if (!PyArg_ParseTuple(args,(char *)"O:_uint8_tArray_begin",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_uint8_tArray_begin" "', argument " "1"" of type '" "std::vector< uint8_t > *""'");
}
arg1 = reinterpret_cast< std::vector< uint8_t > * >(argp1);
result = (arg1)->begin();
resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< unsigned char >::iterator & >(result)),
swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__uint8_tArray_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< uint8_t > *arg1 = (std::vector< uint8_t > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
SwigValueWrapper< std::vector< unsigned char >::iterator > result;
if (!PyArg_ParseTuple(args,(char *)"O:_uint8_tArray_end",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_uint8_tArray_end" "', argument " "1"" of type '" "std::vector< uint8_t > *""'");
}
arg1 = reinterpret_cast< std::vector< uint8_t > * >(argp1);
result = (arg1)->end();
resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< unsigned char >::iterator & >(result)),
swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__uint8_tArray_rbegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< uint8_t > *arg1 = (std::vector< uint8_t > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
SwigValueWrapper< std::vector< unsigned char >::reverse_iterator > result;
if (!PyArg_ParseTuple(args,(char *)"O:_uint8_tArray_rbegin",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_uint8_tArray_rbegin" "', argument " "1"" of type '" "std::vector< uint8_t > *""'");
}
arg1 = reinterpret_cast< std::vector< uint8_t > * >(argp1);
result = (arg1)->rbegin();
resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< unsigned char >::reverse_iterator & >(result)),
swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__uint8_tArray_rend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< uint8_t > *arg1 = (std::vector< uint8_t > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
SwigValueWrapper< std::vector< unsigned char >::reverse_iterator > result;
if (!PyArg_ParseTuple(args,(char *)"O:_uint8_tArray_rend",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_uint8_tArray_rend" "', argument " "1"" of type '" "std::vector< uint8_t > *""'");
}
arg1 = reinterpret_cast< std::vector< uint8_t > * >(argp1);
result = (arg1)->rend();
resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< unsigned char >::reverse_iterator & >(result)),
swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__uint8_tArray_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< uint8_t > *arg1 = (std::vector< uint8_t > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:_uint8_tArray_clear",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_uint8_tArray_clear" "', argument " "1"" of type '" "std::vector< uint8_t > *""'");
}
arg1 = reinterpret_cast< std::vector< uint8_t > * >(argp1);
(arg1)->clear();
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__uint8_tArray_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< uint8_t > *arg1 = (std::vector< uint8_t > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
SwigValueWrapper< std::allocator< unsigned char > > result;
if (!PyArg_ParseTuple(args,(char *)"O:_uint8_tArray_get_allocator",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_uint8_tArray_get_allocator" "', argument " "1"" of type '" "std::vector< uint8_t > const *""'");
}
arg1 = reinterpret_cast< std::vector< uint8_t > * >(argp1);
result = ((std::vector< uint8_t > const *)arg1)->get_allocator();
resultobj = SWIG_NewPointerObj((new std::vector< unsigned char >::allocator_type(static_cast< const std::vector< unsigned char >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_unsigned_char_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__uint8_tArray__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< unsigned char >::size_type arg1 ;
size_t val1 ;
int ecode1 = 0 ;
PyObject * obj0 = 0 ;
std::vector< uint8_t > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__uint8_tArray",&obj0)) SWIG_fail;
ecode1 = SWIG_AsVal_size_t(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new__uint8_tArray" "', argument " "1"" of type '" "std::vector< unsigned char >::size_type""'");
}
arg1 = static_cast< std::vector< unsigned char >::size_type >(val1);
result = (std::vector< uint8_t > *)new std::vector< uint8_t >(arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__uint8_tArray_pop_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< uint8_t > *arg1 = (std::vector< uint8_t > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:_uint8_tArray_pop_back",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_uint8_tArray_pop_back" "', argument " "1"" of type '" "std::vector< uint8_t > *""'");
}
arg1 = reinterpret_cast< std::vector< uint8_t > * >(argp1);
(arg1)->pop_back();
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__uint8_tArray_resize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< uint8_t > *arg1 = (std::vector< uint8_t > *) 0 ;
std::vector< unsigned char >::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:_uint8_tArray_resize",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_uint8_tArray_resize" "', argument " "1"" of type '" "std::vector< uint8_t > *""'");
}
arg1 = reinterpret_cast< std::vector< uint8_t > * >(argp1);
ecode2 = SWIG_AsVal_size_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_uint8_tArray_resize" "', argument " "2"" of type '" "std::vector< unsigned char >::size_type""'");
}
arg2 = static_cast< std::vector< unsigned char >::size_type >(val2);
(arg1)->resize(arg2);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__uint8_tArray_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< uint8_t > *arg1 = (std::vector< uint8_t > *) 0 ;
SwigValueWrapper< std::vector< unsigned char >::iterator > arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
swig::SwigPyIterator *iter2 = 0 ;
int res2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
SwigValueWrapper< std::vector< unsigned char >::iterator > result;
if (!PyArg_ParseTuple(args,(char *)"OO:_uint8_tArray_erase",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_uint8_tArray_erase" "', argument " "1"" of type '" "std::vector< uint8_t > *""'");
}
arg1 = reinterpret_cast< std::vector< uint8_t > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
if (!SWIG_IsOK(res2) || !iter2) {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "_uint8_tArray_erase" "', argument " "2"" of type '" "std::vector< unsigned char >::iterator""'");
} else {
swig::SwigPyIterator_T<std::vector< unsigned char >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< unsigned char >::iterator > *>(iter2);
if (iter_t) {
arg2 = iter_t->get_current();
} else {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "_uint8_tArray_erase" "', argument " "2"" of type '" "std::vector< unsigned char >::iterator""'");
}
}
result = std_vector_Sl_uint8_t_Sg__erase__SWIG_0(arg1,arg2);
resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< unsigned char >::iterator & >(result)),
swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__uint8_tArray_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< uint8_t > *arg1 = (std::vector< uint8_t > *) 0 ;
SwigValueWrapper< std::vector< unsigned char >::iterator > arg2 ;
SwigValueWrapper< std::vector< unsigned char >::iterator > arg3 ;
void *argp1 = 0 ;
int res1 = 0 ;
swig::SwigPyIterator *iter2 = 0 ;
int res2 ;
swig::SwigPyIterator *iter3 = 0 ;
int res3 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
SwigValueWrapper< std::vector< unsigned char >::iterator > result;
if (!PyArg_ParseTuple(args,(char *)"OOO:_uint8_tArray_erase",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_uint8_tArray_erase" "', argument " "1"" of type '" "std::vector< uint8_t > *""'");
}
arg1 = reinterpret_cast< std::vector< uint8_t > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
if (!SWIG_IsOK(res2) || !iter2) {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "_uint8_tArray_erase" "', argument " "2"" of type '" "std::vector< unsigned char >::iterator""'");
} else {
swig::SwigPyIterator_T<std::vector< unsigned char >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< unsigned char >::iterator > *>(iter2);
if (iter_t) {
arg2 = iter_t->get_current();
} else {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "_uint8_tArray_erase" "', argument " "2"" of type '" "std::vector< unsigned char >::iterator""'");
}
}
res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
if (!SWIG_IsOK(res3) || !iter3) {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "_uint8_tArray_erase" "', argument " "3"" of type '" "std::vector< unsigned char >::iterator""'");
} else {
swig::SwigPyIterator_T<std::vector< unsigned char >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< unsigned char >::iterator > *>(iter3);
if (iter_t) {
arg3 = iter_t->get_current();
} else {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "_uint8_tArray_erase" "', argument " "3"" of type '" "std::vector< unsigned char >::iterator""'");
}
}
result = std_vector_Sl_uint8_t_Sg__erase__SWIG_1(arg1,arg2,arg3);
resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< unsigned char >::iterator & >(result)),
swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__uint8_tArray_erase(PyObject *self, PyObject *args) {
Py_ssize_t argc;
PyObject *argv[4] = {
0
};
Py_ssize_t ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = args ? PyObject_Length(args) : 0;
for (ii = 0; (ii < 3) && (ii < argc); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 2) {
int _v;
int res = swig::asptr(argv[0], (std::vector< unsigned char,std::allocator< unsigned char > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
swig::SwigPyIterator *iter = 0;
int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
_v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< unsigned char >::iterator > *>(iter) != 0));
if (_v) {
return _wrap__uint8_tArray_erase__SWIG_0(self, args);
}
}
}
if (argc == 3) {
int _v;
int res = swig::asptr(argv[0], (std::vector< unsigned char,std::allocator< unsigned char > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
swig::SwigPyIterator *iter = 0;
int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
_v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< unsigned char >::iterator > *>(iter) != 0));
if (_v) {
swig::SwigPyIterator *iter = 0;
int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
_v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< unsigned char >::iterator > *>(iter) != 0));
if (_v) {
return _wrap__uint8_tArray_erase__SWIG_1(self, args);
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function '_uint8_tArray_erase'.\n"
" Possible C/C++ prototypes are:\n"
" std::vector< uint8_t >::erase(std::vector< unsigned char >::iterator)\n"
" std::vector< uint8_t >::erase(std::vector< unsigned char >::iterator,std::vector< unsigned char >::iterator)\n");
return 0;
}
SWIGINTERN PyObject *_wrap_new__uint8_tArray__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< unsigned char >::size_type arg1 ;
std::vector< unsigned char >::value_type *arg2 = 0 ;
size_t val1 ;
int ecode1 = 0 ;
std::vector< unsigned char >::value_type temp2 ;
unsigned char val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
std::vector< uint8_t > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:new__uint8_tArray",&obj0,&obj1)) SWIG_fail;
ecode1 = SWIG_AsVal_size_t(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new__uint8_tArray" "', argument " "1"" of type '" "std::vector< unsigned char >::size_type""'");
}
arg1 = static_cast< std::vector< unsigned char >::size_type >(val1);
ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new__uint8_tArray" "', argument " "2"" of type '" "std::vector< unsigned char >::value_type""'");
}
temp2 = static_cast< std::vector< unsigned char >::value_type >(val2);
arg2 = &temp2;
result = (std::vector< uint8_t > *)new std::vector< uint8_t >(arg1,(std::vector< unsigned char >::value_type const &)*arg2);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__uint8_tArray(PyObject *self, PyObject *args) {
Py_ssize_t argc;
PyObject *argv[3] = {
0
};
Py_ssize_t ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = args ? PyObject_Length(args) : 0;
for (ii = 0; (ii < 2) && (ii < argc); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 0) {
return _wrap_new__uint8_tArray__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__uint8_tArray__SWIG_2(self, args);
}
}
if (argc == 1) {
int _v;
int res = swig::asptr(argv[0], (std::vector< unsigned char,std::allocator< unsigned char > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__uint8_tArray__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_unsigned_SS_char(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_new__uint8_tArray__SWIG_3(self, args);
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new__uint8_tArray'.\n"
" Possible C/C++ prototypes are:\n"
" std::vector< uint8_t >::vector()\n"
" std::vector< uint8_t >::vector(std::vector< uint8_t > const &)\n"
" std::vector< uint8_t >::vector(std::vector< unsigned char >::size_type)\n"
" std::vector< uint8_t >::vector(std::vector< unsigned char >::size_type,std::vector< unsigned char >::value_type const &)\n");
return 0;
}
SWIGINTERN PyObject *_wrap__uint8_tArray_push_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< uint8_t > *arg1 = (std::vector< uint8_t > *) 0 ;
std::vector< unsigned char >::value_type *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
std::vector< unsigned char >::value_type temp2 ;
unsigned char val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:_uint8_tArray_push_back",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_uint8_tArray_push_back" "', argument " "1"" of type '" "std::vector< uint8_t > *""'");
}
arg1 = reinterpret_cast< std::vector< uint8_t > * >(argp1);
ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_uint8_tArray_push_back" "', argument " "2"" of type '" "std::vector< unsigned char >::value_type""'");
}
temp2 = static_cast< std::vector< unsigned char >::value_type >(val2);
arg2 = &temp2;
(arg1)->push_back((std::vector< unsigned char >::value_type const &)*arg2);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__uint8_tArray_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< uint8_t > *arg1 = (std::vector< uint8_t > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
std::vector< unsigned char >::value_type *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:_uint8_tArray_front",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_uint8_tArray_front" "', argument " "1"" of type '" "std::vector< uint8_t > const *""'");
}
arg1 = reinterpret_cast< std::vector< uint8_t > * >(argp1);
result = (std::vector< unsigned char >::value_type *) &((std::vector< uint8_t > const *)arg1)->front();
resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(*result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__uint8_tArray_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< uint8_t > *arg1 = (std::vector< uint8_t > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
std::vector< unsigned char >::value_type *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:_uint8_tArray_back",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_uint8_tArray_back" "', argument " "1"" of type '" "std::vector< uint8_t > const *""'");
}
arg1 = reinterpret_cast< std::vector< uint8_t > * >(argp1);
result = (std::vector< unsigned char >::value_type *) &((std::vector< uint8_t > const *)arg1)->back();
resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(*result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__uint8_tArray_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< uint8_t > *arg1 = (std::vector< uint8_t > *) 0 ;
std::vector< unsigned char >::size_type arg2 ;
std::vector< unsigned char >::value_type *arg3 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
size_t val2 ;
int ecode2 = 0 ;
std::vector< unsigned char >::value_type temp3 ;
unsigned char val3 ;
int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:_uint8_tArray_assign",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_uint8_tArray_assign" "', argument " "1"" of type '" "std::vector< uint8_t > *""'");
}
arg1 = reinterpret_cast< std::vector< uint8_t > * >(argp1);
ecode2 = SWIG_AsVal_size_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_uint8_tArray_assign" "', argument " "2"" of type '" "std::vector< unsigned char >::size_type""'");
}
arg2 = static_cast< std::vector< unsigned char >::size_type >(val2);
ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "_uint8_tArray_assign" "', argument " "3"" of type '" "std::vector< unsigned char >::value_type""'");
}
temp3 = static_cast< std::vector< unsigned char >::value_type >(val3);
arg3 = &temp3;
(arg1)->assign(arg2,(std::vector< unsigned char >::value_type const &)*arg3);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__uint8_tArray_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< uint8_t > *arg1 = (std::vector< uint8_t > *) 0 ;
std::vector< unsigned char >::size_type arg2 ;
std::vector< unsigned char >::value_type *arg3 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
size_t val2 ;
int ecode2 = 0 ;
std::vector< unsigned char >::value_type temp3 ;
unsigned char val3 ;
int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:_uint8_tArray_resize",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_uint8_tArray_resize" "', argument " "1"" of type '" "std::vector< uint8_t > *""'");
}
arg1 = reinterpret_cast< std::vector< uint8_t > * >(argp1);
ecode2 = SWIG_AsVal_size_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_uint8_tArray_resize" "', argument " "2"" of type '" "std::vector< unsigned char >::size_type""'");
}
arg2 = static_cast< std::vector< unsigned char >::size_type >(val2);
ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "_uint8_tArray_resize" "', argument " "3"" of type '" "std::vector< unsigned char >::value_type""'");
}
temp3 = static_cast< std::vector< unsigned char >::value_type >(val3);
arg3 = &temp3;
(arg1)->resize(arg2,(std::vector< unsigned char >::value_type const &)*arg3);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__uint8_tArray_resize(PyObject *self, PyObject *args) {
Py_ssize_t argc;
PyObject *argv[4] = {
0
};
Py_ssize_t ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = args ? PyObject_Length(args) : 0;
for (ii = 0; (ii < 3) && (ii < argc); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 2) {
int _v;
int res = swig::asptr(argv[0], (std::vector< unsigned char,std::allocator< unsigned char > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_size_t(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap__uint8_tArray_resize__SWIG_0(self, args);
}
}
}
if (argc == 3) {
int _v;
int res = swig::asptr(argv[0], (std::vector< unsigned char,std::allocator< unsigned char > >**)(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_unsigned_SS_char(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap__uint8_tArray_resize__SWIG_1(self, args);
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function '_uint8_tArray_resize'.\n"
" Possible C/C++ prototypes are:\n"
" std::vector< uint8_t >::resize(std::vector< unsigned char >::size_type)\n"
" std::vector< uint8_t >::resize(std::vector< unsigned char >::size_type,std::vector< unsigned char >::value_type const &)\n");
return 0;
}
SWIGINTERN PyObject *_wrap__uint8_tArray_insert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< uint8_t > *arg1 = (std::vector< uint8_t > *) 0 ;
SwigValueWrapper< std::vector< unsigned char >::iterator > arg2 ;
std::vector< unsigned char >::value_type *arg3 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
swig::SwigPyIterator *iter2 = 0 ;
int res2 ;
std::vector< unsigned char >::value_type temp3 ;
unsigned char val3 ;
int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
SwigValueWrapper< std::vector< unsigned char >::iterator > result;
if (!PyArg_ParseTuple(args,(char *)"OOO:_uint8_tArray_insert",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_uint8_tArray_insert" "', argument " "1"" of type '" "std::vector< uint8_t > *""'");
}
arg1 = reinterpret_cast< std::vector< uint8_t > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
if (!SWIG_IsOK(res2) || !iter2) {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "_uint8_tArray_insert" "', argument " "2"" of type '" "std::vector< unsigned char >::iterator""'");
} else {
swig::SwigPyIterator_T<std::vector< unsigned char >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< unsigned char >::iterator > *>(iter2);
if (iter_t) {
arg2 = iter_t->get_current();
} else {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "_uint8_tArray_insert" "', argument " "2"" of type '" "std::vector< unsigned char >::iterator""'");
}
}
ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "_uint8_tArray_insert" "', argument " "3"" of type '" "std::vector< unsigned char >::value_type""'");
}
temp3 = static_cast< std::vector< unsigned char >::value_type >(val3);
arg3 = &temp3;
result = std_vector_Sl_uint8_t_Sg__insert__SWIG_0(arg1,arg2,(unsigned char const &)*arg3);
resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< unsigned char >::iterator & >(result)),
swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__uint8_tArray_insert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< uint8_t > *arg1 = (std::vector< uint8_t > *) 0 ;
SwigValueWrapper< std::vector< unsigned char >::iterator > arg2 ;
std::vector< unsigned char >::size_type arg3 ;
std::vector< unsigned char >::value_type *arg4 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
swig::SwigPyIterator *iter2 = 0 ;
int res2 ;
size_t val3 ;
int ecode3 = 0 ;
std::vector< unsigned char >::value_type temp4 ;
unsigned char val4 ;
int ecode4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOO:_uint8_tArray_insert",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_uint8_tArray_insert" "', argument " "1"" of type '" "std::vector< uint8_t > *""'");
}
arg1 = reinterpret_cast< std::vector< uint8_t > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
if (!SWIG_IsOK(res2) || !iter2) {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "_uint8_tArray_insert" "', argument " "2"" of type '" "std::vector< unsigned char >::iterator""'");
} else {
swig::SwigPyIterator_T<std::vector< unsigned char >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< unsigned char >::iterator > *>(iter2);
if (iter_t) {
arg2 = iter_t->get_current();
} else {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "_uint8_tArray_insert" "', argument " "2"" of type '" "std::vector< unsigned char >::iterator""'");
}
}
ecode3 = SWIG_AsVal_size_t(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "_uint8_tArray_insert" "', argument " "3"" of type '" "std::vector< unsigned char >::size_type""'");
}
arg3 = static_cast< std::vector< unsigned char >::size_type >(val3);
ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "_uint8_tArray_insert" "', argument " "4"" of type '" "std::vector< unsigned char >::value_type""'");
}
temp4 = static_cast< std::vector< unsigned char >::value_type >(val4);
arg4 = &temp4;
std_vector_Sl_uint8_t_Sg__insert__SWIG_1(arg1,arg2,arg3,(unsigned char const &)*arg4);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__uint8_tArray_insert(PyObject *self, PyObject *args) {
Py_ssize_t argc;
PyObject *argv[5] = {
0
};
Py_ssize_t ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = args ? PyObject_Length(args) : 0;
for (ii = 0; (ii < 4) && (ii < argc); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 3) {
int _v;
int res = swig::asptr(argv[0], (std::vector< unsigned char,std::allocator< unsigned char > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
swig::SwigPyIterator *iter = 0;
int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
_v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< unsigned char >::iterator > *>(iter) != 0));
if (_v) {
{
int res = SWIG_AsVal_unsigned_SS_char(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap__uint8_tArray_insert__SWIG_0(self, args);
}
}
}
}
if (argc == 4) {
int _v;
int res = swig::asptr(argv[0], (std::vector< unsigned char,std::allocator< unsigned char > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
swig::SwigPyIterator *iter = 0;
int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
_v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< unsigned char >::iterator > *>(iter) != 0));
if (_v) {
{
int res = SWIG_AsVal_size_t(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_unsigned_SS_char(argv[3], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap__uint8_tArray_insert__SWIG_1(self, args);
}
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function '_uint8_tArray_insert'.\n"
" Possible C/C++ prototypes are:\n"
" std::vector< uint8_t >::insert(std::vector< unsigned char >::iterator,std::vector< unsigned char >::value_type const &)\n"
" std::vector< uint8_t >::insert(std::vector< unsigned char >::iterator,std::vector< unsigned char >::size_type,std::vector< unsigned char >::value_type const &)\n");
return 0;
}
SWIGINTERN PyObject *_wrap__uint8_tArray_reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< uint8_t > *arg1 = (std::vector< uint8_t > *) 0 ;
std::vector< unsigned char >::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:_uint8_tArray_reserve",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_uint8_tArray_reserve" "', argument " "1"" of type '" "std::vector< uint8_t > *""'");
}
arg1 = reinterpret_cast< std::vector< uint8_t > * >(argp1);
ecode2 = SWIG_AsVal_size_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_uint8_tArray_reserve" "', argument " "2"" of type '" "std::vector< unsigned char >::size_type""'");
}
arg2 = static_cast< std::vector< unsigned char >::size_type >(val2);
(arg1)->reserve(arg2);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__uint8_tArray_capacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< uint8_t > *arg1 = (std::vector< uint8_t > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
std::vector< unsigned char >::size_type result;
if (!PyArg_ParseTuple(args,(char *)"O:_uint8_tArray_capacity",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_uint8_tArray_capacity" "', argument " "1"" of type '" "std::vector< uint8_t > const *""'");
}
arg1 = reinterpret_cast< std::vector< uint8_t > * >(argp1);
result = ((std::vector< uint8_t > const *)arg1)->capacity();
resultobj = SWIG_From_size_t(static_cast< size_t >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete__uint8_tArray(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< uint8_t > *arg1 = (std::vector< uint8_t > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete__uint8_tArray",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__uint8_tArray" "', argument " "1"" of type '" "std::vector< uint8_t > *""'");
}
arg1 = reinterpret_cast< std::vector< uint8_t > * >(argp1);
delete arg1;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_uint8_tArray_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_new__Matx_uint8_t_2_1__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
unsigned char *arg1 = (unsigned char *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
cv::Matx< uint8_t,2,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__Matx_uint8_t_2_1",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_unsigned_char, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_uint8_t_2_1" "', argument " "1"" of type '" "unsigned char const *""'");
}
arg1 = reinterpret_cast< unsigned char * >(argp1);
result = (cv::Matx< uint8_t,2,1 > *)new cv::Matx< uint8_t,2,1 >((unsigned char const *)arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_unsigned_char_2_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_uint8_t_2_1_all(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
unsigned char arg1 ;
unsigned char val1 ;
int ecode1 = 0 ;
PyObject * obj0 = 0 ;
SwigValueWrapper< cv::Matx< unsigned char,2,1 > > result;
if (!PyArg_ParseTuple(args,(char *)"O:_Matx_uint8_t_2_1_all",&obj0)) SWIG_fail;
ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_Matx_uint8_t_2_1_all" "', argument " "1"" of type '" "unsigned char""'");
}
arg1 = static_cast< unsigned char >(val1);
result = cv::Matx< uint8_t,2,1 >::SWIGTEMPLATEDISAMBIGUATOR all(arg1);
resultobj = SWIG_NewPointerObj((new cv::Matx< uint8_t,2,1 >(static_cast< const cv::Matx< uint8_t,2,1 >& >(result))), SWIGTYPE_p_cv__MatxT_unsigned_char_2_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_uint8_t_2_1_zeros(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
SwigValueWrapper< cv::Matx< unsigned char,2,1 > > result;
if (!PyArg_ParseTuple(args,(char *)":_Matx_uint8_t_2_1_zeros")) SWIG_fail;
result = cv::Matx< uint8_t,2,1 >::SWIGTEMPLATEDISAMBIGUATOR zeros();
resultobj = SWIG_NewPointerObj((new cv::Matx< uint8_t,2,1 >(static_cast< const cv::Matx< uint8_t,2,1 >& >(result))), SWIGTYPE_p_cv__MatxT_unsigned_char_2_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_uint8_t_2_1_ones(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
SwigValueWrapper< cv::Matx< unsigned char,2,1 > > result;
if (!PyArg_ParseTuple(args,(char *)":_Matx_uint8_t_2_1_ones")) SWIG_fail;
result = cv::Matx< uint8_t,2,1 >::SWIGTEMPLATEDISAMBIGUATOR ones();
resultobj = SWIG_NewPointerObj((new cv::Matx< uint8_t,2,1 >(static_cast< const cv::Matx< uint8_t,2,1 >& >(result))), SWIGTYPE_p_cv__MatxT_unsigned_char_2_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_uint8_t_2_1_eye(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
SwigValueWrapper< cv::Matx< unsigned char,2,1 > > result;
if (!PyArg_ParseTuple(args,(char *)":_Matx_uint8_t_2_1_eye")) SWIG_fail;
result = cv::Matx< uint8_t,2,1 >::SWIGTEMPLATEDISAMBIGUATOR eye();
resultobj = SWIG_NewPointerObj((new cv::Matx< uint8_t,2,1 >(static_cast< const cv::Matx< uint8_t,2,1 >& >(result))), SWIGTYPE_p_cv__MatxT_unsigned_char_2_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_uint8_t_2_1_randu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
unsigned char arg1 ;
unsigned char arg2 ;
unsigned char val1 ;
int ecode1 = 0 ;
unsigned char val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
SwigValueWrapper< cv::Matx< unsigned char,2,1 > > result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_uint8_t_2_1_randu",&obj0,&obj1)) SWIG_fail;
ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_Matx_uint8_t_2_1_randu" "', argument " "1"" of type '" "unsigned char""'");
}
arg1 = static_cast< unsigned char >(val1);
ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_Matx_uint8_t_2_1_randu" "', argument " "2"" of type '" "unsigned char""'");
}
arg2 = static_cast< unsigned char >(val2);
result = cv::Matx< uint8_t,2,1 >::SWIGTEMPLATEDISAMBIGUATOR randu(arg1,arg2);
resultobj = SWIG_NewPointerObj((new cv::Matx< uint8_t,2,1 >(static_cast< const cv::Matx< uint8_t,2,1 >& >(result))), SWIGTYPE_p_cv__MatxT_unsigned_char_2_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_uint8_t_2_1_randn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
unsigned char arg1 ;
unsigned char arg2 ;
unsigned char val1 ;
int ecode1 = 0 ;
unsigned char val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
SwigValueWrapper< cv::Matx< unsigned char,2,1 > > result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_uint8_t_2_1_randn",&obj0,&obj1)) SWIG_fail;
ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_Matx_uint8_t_2_1_randn" "', argument " "1"" of type '" "unsigned char""'");
}
arg1 = static_cast< unsigned char >(val1);
ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_Matx_uint8_t_2_1_randn" "', argument " "2"" of type '" "unsigned char""'");
}
arg2 = static_cast< unsigned char >(val2);
result = cv::Matx< uint8_t,2,1 >::SWIGTEMPLATEDISAMBIGUATOR randn(arg1,arg2);
resultobj = SWIG_NewPointerObj((new cv::Matx< uint8_t,2,1 >(static_cast< const cv::Matx< uint8_t,2,1 >& >(result))), SWIGTYPE_p_cv__MatxT_unsigned_char_2_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_uint8_t_2_1_dot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< uint8_t,2,1 > *arg1 = (cv::Matx< uint8_t,2,1 > *) 0 ;
cv::Matx< unsigned char,2,1 > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
unsigned char result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_uint8_t_2_1_dot",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_unsigned_char_2_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_uint8_t_2_1_dot" "', argument " "1"" of type '" "cv::Matx< uint8_t,2,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< uint8_t,2,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_unsigned_char_2_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_uint8_t_2_1_dot" "', argument " "2"" of type '" "cv::Matx< unsigned char,2,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Matx_uint8_t_2_1_dot" "', argument " "2"" of type '" "cv::Matx< unsigned char,2,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< unsigned char,2,1 > * >(argp2);
result = (unsigned char)((cv::Matx< uint8_t,2,1 > const *)arg1)->dot((cv::Matx< unsigned char,2,1 > const &)*arg2);
resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_uint8_t_2_1_ddot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< uint8_t,2,1 > *arg1 = (cv::Matx< uint8_t,2,1 > *) 0 ;
cv::Matx< unsigned char,2,1 > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
double result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_uint8_t_2_1_ddot",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_unsigned_char_2_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_uint8_t_2_1_ddot" "', argument " "1"" of type '" "cv::Matx< uint8_t,2,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< uint8_t,2,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_unsigned_char_2_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_uint8_t_2_1_ddot" "', argument " "2"" of type '" "cv::Matx< unsigned char,2,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Matx_uint8_t_2_1_ddot" "', argument " "2"" of type '" "cv::Matx< unsigned char,2,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< unsigned char,2,1 > * >(argp2);
result = (double)((cv::Matx< uint8_t,2,1 > const *)arg1)->ddot((cv::Matx< unsigned char,2,1 > const &)*arg2);
resultobj = SWIG_From_double(static_cast< double >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_uint8_t_2_1_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< uint8_t,2,1 > *arg1 = (cv::Matx< uint8_t,2,1 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
SwigValueWrapper< cv::Matx< unsigned char,1,2 > > result;
if (!PyArg_ParseTuple(args,(char *)"O:_Matx_uint8_t_2_1_t",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_unsigned_char_2_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_uint8_t_2_1_t" "', argument " "1"" of type '" "cv::Matx< uint8_t,2,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< uint8_t,2,1 > * >(argp1);
result = ((cv::Matx< uint8_t,2,1 > const *)arg1)->t();
resultobj = SWIG_NewPointerObj((new cv::Matx< unsigned char,1,2 >(static_cast< const cv::Matx< unsigned char,1,2 >& >(result))), SWIGTYPE_p_cv__MatxT_unsigned_char_1_2_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_uint8_t_2_1_mul(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< uint8_t,2,1 > *arg1 = (cv::Matx< uint8_t,2,1 > *) 0 ;
cv::Matx< unsigned char,2,1 > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
SwigValueWrapper< cv::Matx< unsigned char,2,1 > > result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_uint8_t_2_1_mul",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_unsigned_char_2_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_uint8_t_2_1_mul" "', argument " "1"" of type '" "cv::Matx< uint8_t,2,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< uint8_t,2,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_unsigned_char_2_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_uint8_t_2_1_mul" "', argument " "2"" of type '" "cv::Matx< unsigned char,2,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Matx_uint8_t_2_1_mul" "', argument " "2"" of type '" "cv::Matx< unsigned char,2,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< unsigned char,2,1 > * >(argp2);
result = ((cv::Matx< uint8_t,2,1 > const *)arg1)->mul((cv::Matx< unsigned char,2,1 > const &)*arg2);
resultobj = SWIG_NewPointerObj((new cv::Matx< unsigned char,2,1 >(static_cast< const cv::Matx< unsigned char,2,1 >& >(result))), SWIGTYPE_p_cv__MatxT_unsigned_char_2_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_uint8_t_2_1_div(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< uint8_t,2,1 > *arg1 = (cv::Matx< uint8_t,2,1 > *) 0 ;
cv::Matx< unsigned char,2,1 > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
SwigValueWrapper< cv::Matx< unsigned char,2,1 > > result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_uint8_t_2_1_div",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_unsigned_char_2_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_uint8_t_2_1_div" "', argument " "1"" of type '" "cv::Matx< uint8_t,2,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< uint8_t,2,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_unsigned_char_2_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_uint8_t_2_1_div" "', argument " "2"" of type '" "cv::Matx< unsigned char,2,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Matx_uint8_t_2_1_div" "', argument " "2"" of type '" "cv::Matx< unsigned char,2,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< unsigned char,2,1 > * >(argp2);
result = ((cv::Matx< uint8_t,2,1 > const *)arg1)->div((cv::Matx< unsigned char,2,1 > const &)*arg2);
resultobj = SWIG_NewPointerObj((new cv::Matx< unsigned char,2,1 >(static_cast< const cv::Matx< unsigned char,2,1 >& >(result))), SWIGTYPE_p_cv__MatxT_unsigned_char_2_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_uint8_t_2_1___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< uint8_t,2,1 > *arg1 = (cv::Matx< uint8_t,2,1 > *) 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 ;
unsigned char *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:_Matx_uint8_t_2_1___call__",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_unsigned_char_2_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_uint8_t_2_1___call__" "', argument " "1"" of type '" "cv::Matx< uint8_t,2,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< uint8_t,2,1 > * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_Matx_uint8_t_2_1___call__" "', 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 '" "_Matx_uint8_t_2_1___call__" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
result = (unsigned char *) &((cv::Matx< uint8_t,2,1 > const *)arg1)->operator ()(arg2,arg3);
resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(*result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_uint8_t_2_1__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< unsigned char,2,1 > *arg1 = 0 ;
cv::Matx< unsigned char,2,1 > *arg2 = 0 ;
cv::Matx_AddOp 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 ;
cv::Matx< uint8_t,2,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Matx_uint8_t_2_1",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_unsigned_char_2_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_uint8_t_2_1" "', argument " "1"" of type '" "cv::Matx< unsigned char,2,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_uint8_t_2_1" "', argument " "1"" of type '" "cv::Matx< unsigned char,2,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< unsigned char,2,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_unsigned_char_2_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Matx_uint8_t_2_1" "', argument " "2"" of type '" "cv::Matx< unsigned char,2,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_uint8_t_2_1" "', argument " "2"" of type '" "cv::Matx< unsigned char,2,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< unsigned char,2,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_AddOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Matx_uint8_t_2_1" "', argument " "3"" of type '" "cv::Matx_AddOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_uint8_t_2_1" "', argument " "3"" of type '" "cv::Matx_AddOp""'");
} else {
cv::Matx_AddOp * temp = reinterpret_cast< cv::Matx_AddOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Matx< uint8_t,2,1 > *)new cv::Matx< uint8_t,2,1 >((cv::Matx< unsigned char,2,1 > const &)*arg1,(cv::Matx< unsigned char,2,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_unsigned_char_2_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_uint8_t_2_1__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< unsigned char,2,1 > *arg1 = 0 ;
cv::Matx< unsigned char,2,1 > *arg2 = 0 ;
cv::Matx_SubOp 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 ;
cv::Matx< uint8_t,2,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Matx_uint8_t_2_1",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_unsigned_char_2_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_uint8_t_2_1" "', argument " "1"" of type '" "cv::Matx< unsigned char,2,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_uint8_t_2_1" "', argument " "1"" of type '" "cv::Matx< unsigned char,2,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< unsigned char,2,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_unsigned_char_2_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Matx_uint8_t_2_1" "', argument " "2"" of type '" "cv::Matx< unsigned char,2,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_uint8_t_2_1" "', argument " "2"" of type '" "cv::Matx< unsigned char,2,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< unsigned char,2,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_SubOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Matx_uint8_t_2_1" "', argument " "3"" of type '" "cv::Matx_SubOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_uint8_t_2_1" "', argument " "3"" of type '" "cv::Matx_SubOp""'");
} else {
cv::Matx_SubOp * temp = reinterpret_cast< cv::Matx_SubOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Matx< uint8_t,2,1 > *)new cv::Matx< uint8_t,2,1 >((cv::Matx< unsigned char,2,1 > const &)*arg1,(cv::Matx< unsigned char,2,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_unsigned_char_2_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_uint8_t_2_1__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< unsigned char,2,1 > *arg1 = 0 ;
cv::Matx< unsigned char,2,1 > *arg2 = 0 ;
cv::Matx_MulOp 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 ;
cv::Matx< uint8_t,2,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Matx_uint8_t_2_1",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_unsigned_char_2_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_uint8_t_2_1" "', argument " "1"" of type '" "cv::Matx< unsigned char,2,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_uint8_t_2_1" "', argument " "1"" of type '" "cv::Matx< unsigned char,2,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< unsigned char,2,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_unsigned_char_2_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Matx_uint8_t_2_1" "', argument " "2"" of type '" "cv::Matx< unsigned char,2,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_uint8_t_2_1" "', argument " "2"" of type '" "cv::Matx< unsigned char,2,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< unsigned char,2,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_MulOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Matx_uint8_t_2_1" "', argument " "3"" of type '" "cv::Matx_MulOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_uint8_t_2_1" "', argument " "3"" of type '" "cv::Matx_MulOp""'");
} else {
cv::Matx_MulOp * temp = reinterpret_cast< cv::Matx_MulOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Matx< uint8_t,2,1 > *)new cv::Matx< uint8_t,2,1 >((cv::Matx< unsigned char,2,1 > const &)*arg1,(cv::Matx< unsigned char,2,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_unsigned_char_2_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_uint8_t_2_1__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< unsigned char,2,1 > *arg1 = 0 ;
cv::Matx< unsigned char,2,1 > *arg2 = 0 ;
cv::Matx_DivOp 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 ;
cv::Matx< uint8_t,2,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Matx_uint8_t_2_1",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_unsigned_char_2_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_uint8_t_2_1" "', argument " "1"" of type '" "cv::Matx< unsigned char,2,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_uint8_t_2_1" "', argument " "1"" of type '" "cv::Matx< unsigned char,2,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< unsigned char,2,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_unsigned_char_2_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Matx_uint8_t_2_1" "', argument " "2"" of type '" "cv::Matx< unsigned char,2,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_uint8_t_2_1" "', argument " "2"" of type '" "cv::Matx< unsigned char,2,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< unsigned char,2,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_DivOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Matx_uint8_t_2_1" "', argument " "3"" of type '" "cv::Matx_DivOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_uint8_t_2_1" "', argument " "3"" of type '" "cv::Matx_DivOp""'");
} else {
cv::Matx_DivOp * temp = reinterpret_cast< cv::Matx_DivOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Matx< uint8_t,2,1 > *)new cv::Matx< uint8_t,2,1 >((cv::Matx< unsigned char,2,1 > const &)*arg1,(cv::Matx< unsigned char,2,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_unsigned_char_2_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_uint8_t_2_1__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< unsigned char,1,2 > *arg1 = 0 ;
cv::Matx_TOp arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
cv::Matx< uint8_t,2,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:new__Matx_uint8_t_2_1",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_unsigned_char_1_2_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_uint8_t_2_1" "', argument " "1"" of type '" "cv::Matx< unsigned char,1,2 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_uint8_t_2_1" "', argument " "1"" of type '" "cv::Matx< unsigned char,1,2 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< unsigned char,1,2 > * >(argp1);
{
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__Matx_TOp, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Matx_uint8_t_2_1" "', argument " "2"" of type '" "cv::Matx_TOp""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_uint8_t_2_1" "', argument " "2"" of type '" "cv::Matx_TOp""'");
} else {
cv::Matx_TOp * temp = reinterpret_cast< cv::Matx_TOp * >(argp2);
arg2 = *temp;
if (SWIG_IsNewObj(res2)) delete temp;
}
}
result = (cv::Matx< uint8_t,2,1 > *)new cv::Matx< uint8_t,2,1 >((cv::Matx< unsigned char,1,2 > const &)*arg1,arg2);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_unsigned_char_2_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_uint8_t_2_1_val_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< uint8_t,2,1 > *arg1 = (cv::Matx< uint8_t,2,1 > *) 0 ;
unsigned char *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:_Matx_uint8_t_2_1_val_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_unsigned_char_2_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_uint8_t_2_1_val_set" "', argument " "1"" of type '" "cv::Matx< uint8_t,2,1 > *""'");
}
arg1 = reinterpret_cast< cv::Matx< uint8_t,2,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_uint8_t_2_1_val_set" "', argument " "2"" of type '" "unsigned char [2*1]""'");
}
arg2 = reinterpret_cast< unsigned char * >(argp2);
{
if (arg2) {
size_t ii = 0;
for (; ii < (size_t)2*1; ++ii) *(unsigned char *)&arg1->val[ii] = *((unsigned char *)arg2 + ii);
} else {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""val""' of type '""unsigned char [2*1]""'");
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_uint8_t_2_1_val_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< uint8_t,2,1 > *arg1 = (cv::Matx< uint8_t,2,1 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
unsigned char *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:_Matx_uint8_t_2_1_val_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_unsigned_char_2_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_uint8_t_2_1_val_get" "', argument " "1"" of type '" "cv::Matx< uint8_t,2,1 > *""'");
}
arg1 = reinterpret_cast< cv::Matx< uint8_t,2,1 > * >(argp1);
result = (unsigned char *)(unsigned char *) ((arg1)->val);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_uint8_t_2_1__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< cv::Matx< unsigned char,2,1 >::value_type,std::allocator< cv::Matx< uint8_t,2,1 >::value_type > > arg1 ;
PyObject * obj0 = 0 ;
cv::Matx< uint8_t,2,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__Matx_uint8_t_2_1",&obj0)) SWIG_fail;
{
std::vector< unsigned char,std::allocator< unsigned char > > *ptr = (std::vector< unsigned char,std::allocator< unsigned char > > *)0;
int res = swig::asptr(obj0, &ptr);
if (!SWIG_IsOK(res) || !ptr) {
SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new__Matx_uint8_t_2_1" "', argument " "1"" of type '" "std::vector< cv::Matx< unsigned char,2,1 >::value_type,std::allocator< cv::Matx< uint8_t,2,1 >::value_type > >""'");
}
arg1 = *ptr;
if (SWIG_IsNewObj(res)) delete ptr;
}
result = (cv::Matx< uint8_t,2,1 > *)new_cv_Matx_Sl_uint8_t_Sc_2_Sc_1_Sg___SWIG_6(arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_unsigned_char_2_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_uint8_t_2_1(PyObject *self, PyObject *args) {
Py_ssize_t argc;
PyObject *argv[4] = {
0
};
Py_ssize_t ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = args ? PyObject_Length(args) : 0;
for (ii = 0; (ii < 3) && (ii < argc); 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_unsigned_char, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_uint8_t_2_1__SWIG_0(self, args);
}
}
if (argc == 1) {
int _v;
int res = swig::asptr(argv[0], (std::vector< unsigned char,std::allocator< unsigned char > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_uint8_t_2_1__SWIG_6(self, args);
}
}
if (argc == 2) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_unsigned_char_1_2_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__Matx_TOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_uint8_t_2_1__SWIG_5(self, args);
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_unsigned_char_2_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_unsigned_char_2_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_MulOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_uint8_t_2_1__SWIG_3(self, args);
}
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_unsigned_char_2_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_unsigned_char_2_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_DivOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_uint8_t_2_1__SWIG_4(self, args);
}
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_unsigned_char_2_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_unsigned_char_2_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_AddOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_uint8_t_2_1__SWIG_1(self, args);
}
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_unsigned_char_2_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_unsigned_char_2_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_SubOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_uint8_t_2_1__SWIG_2(self, args);
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new__Matx_uint8_t_2_1'.\n"
" Possible C/C++ prototypes are:\n"
" cv::Matx< uint8_t,2,1 >::Matx(unsigned char const *)\n"
" cv::Matx< uint8_t,2,1 >::Matx(cv::Matx< unsigned char,2,1 > const &,cv::Matx< unsigned char,2,1 > const &,cv::Matx_AddOp)\n"
" cv::Matx< uint8_t,2,1 >::Matx(cv::Matx< unsigned char,2,1 > const &,cv::Matx< unsigned char,2,1 > const &,cv::Matx_SubOp)\n"
" cv::Matx< uint8_t,2,1 >::Matx(cv::Matx< unsigned char,2,1 > const &,cv::Matx< unsigned char,2,1 > const &,cv::Matx_MulOp)\n"
" cv::Matx< uint8_t,2,1 >::Matx(cv::Matx< unsigned char,2,1 > const &,cv::Matx< unsigned char,2,1 > const &,cv::Matx_DivOp)\n"
" cv::Matx< uint8_t,2,1 >::Matx(cv::Matx< unsigned char,1,2 > const &,cv::Matx_TOp)\n"
" cv::Matx< uint8_t,2,1 >::Matx(std::vector< cv::Matx< unsigned char,2,1 >::value_type,std::allocator< cv::Matx< uint8_t,2,1 >::value_type > >)\n");
return 0;
}
SWIGINTERN PyObject *_wrap__Matx_uint8_t_2_1___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< uint8_t,2,1 > *arg1 = (cv::Matx< uint8_t,2,1 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
std::string result;
if (!PyArg_ParseTuple(args,(char *)"O:_Matx_uint8_t_2_1___str__",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_unsigned_char_2_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_uint8_t_2_1___str__" "', argument " "1"" of type '" "cv::Matx< uint8_t,2,1 > *""'");
}
arg1 = reinterpret_cast< cv::Matx< uint8_t,2,1 > * >(argp1);
result = cv_Matx_Sl_uint8_t_Sc_2_Sc_1_Sg____str__(arg1);
resultobj = SWIG_From_std_string(static_cast< std::string >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete__Matx_uint8_t_2_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< uint8_t,2,1 > *arg1 = (cv::Matx< uint8_t,2,1 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete__Matx_uint8_t_2_1",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_unsigned_char_2_1_t, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__Matx_uint8_t_2_1" "', argument " "1"" of type '" "cv::Matx< uint8_t,2,1 > *""'");
}
arg1 = reinterpret_cast< cv::Matx< uint8_t,2,1 > * >(argp1);
delete arg1;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_Matx_uint8_t_2_1_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_cv__MatxT_unsigned_char_2_1_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_new__Vec_uint8_t_2__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
unsigned char *arg1 = (unsigned char *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
cv::Vec< uint8_t,2 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__Vec_uint8_t_2",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_unsigned_char, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Vec_uint8_t_2" "', argument " "1"" of type '" "unsigned char const *""'");
}
arg1 = reinterpret_cast< unsigned char * >(argp1);
result = (cv::Vec< uint8_t,2 > *)new cv::Vec< uint8_t,2 >((unsigned char const *)arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__VecT_unsigned_char_2_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Vec_uint8_t_2__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Vec< unsigned char,2 > *arg1 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
cv::Vec< uint8_t,2 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__Vec_uint8_t_2",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__VecT_unsigned_char_2_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Vec_uint8_t_2" "', argument " "1"" of type '" "cv::Vec< unsigned char,2 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_uint8_t_2" "', argument " "1"" of type '" "cv::Vec< unsigned char,2 > const &""'");
}
arg1 = reinterpret_cast< cv::Vec< unsigned char,2 > * >(argp1);
result = (cv::Vec< uint8_t,2 > *)new cv::Vec< uint8_t,2 >((cv::Vec< unsigned char,2 > const &)*arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__VecT_unsigned_char_2_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Vec_uint8_t_2_all(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
unsigned char arg1 ;
unsigned char val1 ;
int ecode1 = 0 ;
PyObject * obj0 = 0 ;
SwigValueWrapper< cv::Vec< unsigned char,2 > > result;
if (!PyArg_ParseTuple(args,(char *)"O:_Vec_uint8_t_2_all",&obj0)) SWIG_fail;
ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_Vec_uint8_t_2_all" "', argument " "1"" of type '" "unsigned char""'");
}
arg1 = static_cast< unsigned char >(val1);
result = cv::Vec< uint8_t,2 >::SWIGTEMPLATEDISAMBIGUATOR all(arg1);
resultobj = SWIG_NewPointerObj((new cv::Vec< uint8_t,2 >(static_cast< const cv::Vec< uint8_t,2 >& >(result))), SWIGTYPE_p_cv__VecT_unsigned_char_2_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Vec_uint8_t_2_mul(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Vec< uint8_t,2 > *arg1 = (cv::Vec< uint8_t,2 > *) 0 ;
cv::Vec< unsigned char,2 > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
SwigValueWrapper< cv::Vec< unsigned char,2 > > result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Vec_uint8_t_2_mul",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__VecT_unsigned_char_2_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Vec_uint8_t_2_mul" "', argument " "1"" of type '" "cv::Vec< uint8_t,2 > const *""'");
}
arg1 = reinterpret_cast< cv::Vec< uint8_t,2 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__VecT_unsigned_char_2_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Vec_uint8_t_2_mul" "', argument " "2"" of type '" "cv::Vec< unsigned char,2 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Vec_uint8_t_2_mul" "', argument " "2"" of type '" "cv::Vec< unsigned char,2 > const &""'");
}
arg2 = reinterpret_cast< cv::Vec< unsigned char,2 > * >(argp2);
result = ((cv::Vec< uint8_t,2 > const *)arg1)->mul((cv::Vec< unsigned char,2 > const &)*arg2);
resultobj = SWIG_NewPointerObj((new cv::Vec< uint8_t,2 >(static_cast< const cv::Vec< uint8_t,2 >& >(result))), SWIGTYPE_p_cv__VecT_unsigned_char_2_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Vec_uint8_t_2___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Vec< uint8_t,2 > *arg1 = (cv::Vec< uint8_t,2 > *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
unsigned char *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:_Vec_uint8_t_2___call__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__VecT_unsigned_char_2_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Vec_uint8_t_2___call__" "', argument " "1"" of type '" "cv::Vec< uint8_t,2 > const *""'");
}
arg1 = reinterpret_cast< cv::Vec< uint8_t,2 > * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_Vec_uint8_t_2___call__" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
result = (unsigned char *) &((cv::Vec< uint8_t,2 > const *)arg1)->operator ()(arg2);
resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(*result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Vec_uint8_t_2__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< unsigned char,2,1 > *arg1 = 0 ;
cv::Matx< unsigned char,2,1 > *arg2 = 0 ;
cv::Matx_AddOp 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 ;
cv::Vec< uint8_t,2 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Vec_uint8_t_2",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_unsigned_char_2_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Vec_uint8_t_2" "', argument " "1"" of type '" "cv::Matx< unsigned char,2,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_uint8_t_2" "', argument " "1"" of type '" "cv::Matx< unsigned char,2,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< unsigned char,2,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_unsigned_char_2_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Vec_uint8_t_2" "', argument " "2"" of type '" "cv::Matx< unsigned char,2,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_uint8_t_2" "', argument " "2"" of type '" "cv::Matx< unsigned char,2,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< unsigned char,2,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_AddOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Vec_uint8_t_2" "', argument " "3"" of type '" "cv::Matx_AddOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_uint8_t_2" "', argument " "3"" of type '" "cv::Matx_AddOp""'");
} else {
cv::Matx_AddOp * temp = reinterpret_cast< cv::Matx_AddOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Vec< uint8_t,2 > *)new cv::Vec< uint8_t,2 >((cv::Matx< unsigned char,2,1 > const &)*arg1,(cv::Matx< unsigned char,2,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__VecT_unsigned_char_2_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Vec_uint8_t_2__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< unsigned char,2,1 > *arg1 = 0 ;
cv::Matx< unsigned char,2,1 > *arg2 = 0 ;
cv::Matx_SubOp 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 ;
cv::Vec< uint8_t,2 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Vec_uint8_t_2",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_unsigned_char_2_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Vec_uint8_t_2" "', argument " "1"" of type '" "cv::Matx< unsigned char,2,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_uint8_t_2" "', argument " "1"" of type '" "cv::Matx< unsigned char,2,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< unsigned char,2,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_unsigned_char_2_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Vec_uint8_t_2" "', argument " "2"" of type '" "cv::Matx< unsigned char,2,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_uint8_t_2" "', argument " "2"" of type '" "cv::Matx< unsigned char,2,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< unsigned char,2,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_SubOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Vec_uint8_t_2" "', argument " "3"" of type '" "cv::Matx_SubOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_uint8_t_2" "', argument " "3"" of type '" "cv::Matx_SubOp""'");
} else {
cv::Matx_SubOp * temp = reinterpret_cast< cv::Matx_SubOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Vec< uint8_t,2 > *)new cv::Vec< uint8_t,2 >((cv::Matx< unsigned char,2,1 > const &)*arg1,(cv::Matx< unsigned char,2,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__VecT_unsigned_char_2_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Vec_uint8_t_2__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< cv::Vec< unsigned char,2 >::value_type,std::allocator< cv::Vec< uint8_t,2 >::value_type > > arg1 ;
PyObject * obj0 = 0 ;
cv::Vec< uint8_t,2 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__Vec_uint8_t_2",&obj0)) SWIG_fail;
{
std::vector< unsigned char,std::allocator< unsigned char > > *ptr = (std::vector< unsigned char,std::allocator< unsigned char > > *)0;
int res = swig::asptr(obj0, &ptr);
if (!SWIG_IsOK(res) || !ptr) {
SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new__Vec_uint8_t_2" "', argument " "1"" of type '" "std::vector< cv::Vec< unsigned char,2 >::value_type,std::allocator< cv::Vec< uint8_t,2 >::value_type > >""'");
}
arg1 = *ptr;
if (SWIG_IsNewObj(res)) delete ptr;
}
result = (cv::Vec< uint8_t,2 > *)new_cv_Vec_Sl_uint8_t_Sc_2_Sg___SWIG_4(arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__VecT_unsigned_char_2_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Vec_uint8_t_2(PyObject *self, PyObject *args) {
Py_ssize_t argc;
PyObject *argv[4] = {
0
};
Py_ssize_t ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = args ? PyObject_Length(args) : 0;
for (ii = 0; (ii < 3) && (ii < argc); 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_unsigned_char, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Vec_uint8_t_2__SWIG_0(self, args);
}
}
if (argc == 1) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__VecT_unsigned_char_2_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Vec_uint8_t_2__SWIG_1(self, args);
}
}
if (argc == 1) {
int _v;
int res = swig::asptr(argv[0], (std::vector< unsigned char,std::allocator< unsigned char > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Vec_uint8_t_2__SWIG_4(self, args);
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_unsigned_char_2_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_unsigned_char_2_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_SubOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Vec_uint8_t_2__SWIG_3(self, args);
}
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_unsigned_char_2_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_unsigned_char_2_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_AddOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Vec_uint8_t_2__SWIG_2(self, args);
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new__Vec_uint8_t_2'.\n"
" Possible C/C++ prototypes are:\n"
" cv::Vec< uint8_t,2 >::Vec(unsigned char const *)\n"
" cv::Vec< uint8_t,2 >::Vec(cv::Vec< unsigned char,2 > const &)\n"
" cv::Vec< uint8_t,2 >::Vec(cv::Matx< unsigned char,2,1 > const &,cv::Matx< unsigned char,2,1 > const &,cv::Matx_AddOp)\n"
" cv::Vec< uint8_t,2 >::Vec(cv::Matx< unsigned char,2,1 > const &,cv::Matx< unsigned char,2,1 > const &,cv::Matx_SubOp)\n"
" cv::Vec< uint8_t,2 >::Vec(std::vector< cv::Vec< unsigned char,2 >::value_type,std::allocator< cv::Vec< uint8_t,2 >::value_type > >)\n");
return 0;
}
SWIGINTERN PyObject *_wrap__Vec_uint8_t_2___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Vec< uint8_t,2 > *arg1 = (cv::Vec< uint8_t,2 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
std::string result;
if (!PyArg_ParseTuple(args,(char *)"O:_Vec_uint8_t_2___str__",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__VecT_unsigned_char_2_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Vec_uint8_t_2___str__" "', argument " "1"" of type '" "cv::Vec< uint8_t,2 > *""'");
}
arg1 = reinterpret_cast< cv::Vec< uint8_t,2 > * >(argp1);
result = cv_Vec_Sl_uint8_t_Sc_2_Sg____str__(arg1);
resultobj = SWIG_From_std_string(static_cast< std::string >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete__Vec_uint8_t_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Vec< uint8_t,2 > *arg1 = (cv::Vec< uint8_t,2 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete__Vec_uint8_t_2",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__VecT_unsigned_char_2_t, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__Vec_uint8_t_2" "', argument " "1"" of type '" "cv::Vec< uint8_t,2 > *""'");
}
arg1 = reinterpret_cast< cv::Vec< uint8_t,2 > * >(argp1);
delete arg1;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_Vec_uint8_t_2_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_cv__VecT_unsigned_char_2_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_new__DataType_Vec_uint8_t_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::DataType< cv::Vec< uint8_t,2 > > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new__DataType_Vec_uint8_t_2")) SWIG_fail;
result = (cv::DataType< cv::Vec< uint8_t,2 > > *)new cv::DataType< cv::Vec< uint8_t,2 > >();
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__DataTypeT_cv__VecT_uint8_t_2_t_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete__DataType_Vec_uint8_t_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::DataType< cv::Vec< uint8_t,2 > > *arg1 = (cv::DataType< cv::Vec< uint8_t,2 > > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete__DataType_Vec_uint8_t_2",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__DataTypeT_cv__VecT_uint8_t_2_t_t, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__DataType_Vec_uint8_t_2" "', argument " "1"" of type '" "cv::DataType< cv::Vec< uint8_t,2 > > *""'");
}
arg1 = reinterpret_cast< cv::DataType< cv::Vec< uint8_t,2 > > * >(argp1);
delete arg1;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_DataType_Vec_uint8_t_2_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_cv__DataTypeT_cv__VecT_uint8_t_2_t_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_new__Matx_uint8_t_3_1__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
unsigned char *arg1 = (unsigned char *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
cv::Matx< uint8_t,3,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__Matx_uint8_t_3_1",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_unsigned_char, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_uint8_t_3_1" "', argument " "1"" of type '" "unsigned char const *""'");
}
arg1 = reinterpret_cast< unsigned char * >(argp1);
result = (cv::Matx< uint8_t,3,1 > *)new cv::Matx< uint8_t,3,1 >((unsigned char const *)arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_unsigned_char_3_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_uint8_t_3_1_all(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
unsigned char arg1 ;
unsigned char val1 ;
int ecode1 = 0 ;
PyObject * obj0 = 0 ;
SwigValueWrapper< cv::Matx< unsigned char,3,1 > > result;
if (!PyArg_ParseTuple(args,(char *)"O:_Matx_uint8_t_3_1_all",&obj0)) SWIG_fail;
ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_Matx_uint8_t_3_1_all" "', argument " "1"" of type '" "unsigned char""'");
}
arg1 = static_cast< unsigned char >(val1);
result = cv::Matx< uint8_t,3,1 >::SWIGTEMPLATEDISAMBIGUATOR all(arg1);
resultobj = SWIG_NewPointerObj((new cv::Matx< uint8_t,3,1 >(static_cast< const cv::Matx< uint8_t,3,1 >& >(result))), SWIGTYPE_p_cv__MatxT_unsigned_char_3_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_uint8_t_3_1_zeros(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
SwigValueWrapper< cv::Matx< unsigned char,3,1 > > result;
if (!PyArg_ParseTuple(args,(char *)":_Matx_uint8_t_3_1_zeros")) SWIG_fail;
result = cv::Matx< uint8_t,3,1 >::SWIGTEMPLATEDISAMBIGUATOR zeros();
resultobj = SWIG_NewPointerObj((new cv::Matx< uint8_t,3,1 >(static_cast< const cv::Matx< uint8_t,3,1 >& >(result))), SWIGTYPE_p_cv__MatxT_unsigned_char_3_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_uint8_t_3_1_ones(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
SwigValueWrapper< cv::Matx< unsigned char,3,1 > > result;
if (!PyArg_ParseTuple(args,(char *)":_Matx_uint8_t_3_1_ones")) SWIG_fail;
result = cv::Matx< uint8_t,3,1 >::SWIGTEMPLATEDISAMBIGUATOR ones();
resultobj = SWIG_NewPointerObj((new cv::Matx< uint8_t,3,1 >(static_cast< const cv::Matx< uint8_t,3,1 >& >(result))), SWIGTYPE_p_cv__MatxT_unsigned_char_3_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_uint8_t_3_1_eye(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
SwigValueWrapper< cv::Matx< unsigned char,3,1 > > result;
if (!PyArg_ParseTuple(args,(char *)":_Matx_uint8_t_3_1_eye")) SWIG_fail;
result = cv::Matx< uint8_t,3,1 >::SWIGTEMPLATEDISAMBIGUATOR eye();
resultobj = SWIG_NewPointerObj((new cv::Matx< uint8_t,3,1 >(static_cast< const cv::Matx< uint8_t,3,1 >& >(result))), SWIGTYPE_p_cv__MatxT_unsigned_char_3_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_uint8_t_3_1_randu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
unsigned char arg1 ;
unsigned char arg2 ;
unsigned char val1 ;
int ecode1 = 0 ;
unsigned char val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
SwigValueWrapper< cv::Matx< unsigned char,3,1 > > result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_uint8_t_3_1_randu",&obj0,&obj1)) SWIG_fail;
ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_Matx_uint8_t_3_1_randu" "', argument " "1"" of type '" "unsigned char""'");
}
arg1 = static_cast< unsigned char >(val1);
ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_Matx_uint8_t_3_1_randu" "', argument " "2"" of type '" "unsigned char""'");
}
arg2 = static_cast< unsigned char >(val2);
result = cv::Matx< uint8_t,3,1 >::SWIGTEMPLATEDISAMBIGUATOR randu(arg1,arg2);
resultobj = SWIG_NewPointerObj((new cv::Matx< uint8_t,3,1 >(static_cast< const cv::Matx< uint8_t,3,1 >& >(result))), SWIGTYPE_p_cv__MatxT_unsigned_char_3_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_uint8_t_3_1_randn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
unsigned char arg1 ;
unsigned char arg2 ;
unsigned char val1 ;
int ecode1 = 0 ;
unsigned char val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
SwigValueWrapper< cv::Matx< unsigned char,3,1 > > result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_uint8_t_3_1_randn",&obj0,&obj1)) SWIG_fail;
ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_Matx_uint8_t_3_1_randn" "', argument " "1"" of type '" "unsigned char""'");
}
arg1 = static_cast< unsigned char >(val1);
ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_Matx_uint8_t_3_1_randn" "', argument " "2"" of type '" "unsigned char""'");
}
arg2 = static_cast< unsigned char >(val2);
result = cv::Matx< uint8_t,3,1 >::SWIGTEMPLATEDISAMBIGUATOR randn(arg1,arg2);
resultobj = SWIG_NewPointerObj((new cv::Matx< uint8_t,3,1 >(static_cast< const cv::Matx< uint8_t,3,1 >& >(result))), SWIGTYPE_p_cv__MatxT_unsigned_char_3_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_uint8_t_3_1_dot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< uint8_t,3,1 > *arg1 = (cv::Matx< uint8_t,3,1 > *) 0 ;
cv::Matx< unsigned char,3,1 > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
unsigned char result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_uint8_t_3_1_dot",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_unsigned_char_3_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_uint8_t_3_1_dot" "', argument " "1"" of type '" "cv::Matx< uint8_t,3,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< uint8_t,3,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_unsigned_char_3_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_uint8_t_3_1_dot" "', argument " "2"" of type '" "cv::Matx< unsigned char,3,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Matx_uint8_t_3_1_dot" "', argument " "2"" of type '" "cv::Matx< unsigned char,3,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< unsigned char,3,1 > * >(argp2);
result = (unsigned char)((cv::Matx< uint8_t,3,1 > const *)arg1)->dot((cv::Matx< unsigned char,3,1 > const &)*arg2);
resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_uint8_t_3_1_ddot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< uint8_t,3,1 > *arg1 = (cv::Matx< uint8_t,3,1 > *) 0 ;
cv::Matx< unsigned char,3,1 > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
double result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_uint8_t_3_1_ddot",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_unsigned_char_3_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_uint8_t_3_1_ddot" "', argument " "1"" of type '" "cv::Matx< uint8_t,3,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< uint8_t,3,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_unsigned_char_3_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_uint8_t_3_1_ddot" "', argument " "2"" of type '" "cv::Matx< unsigned char,3,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Matx_uint8_t_3_1_ddot" "', argument " "2"" of type '" "cv::Matx< unsigned char,3,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< unsigned char,3,1 > * >(argp2);
result = (double)((cv::Matx< uint8_t,3,1 > const *)arg1)->ddot((cv::Matx< unsigned char,3,1 > const &)*arg2);
resultobj = SWIG_From_double(static_cast< double >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_uint8_t_3_1_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< uint8_t,3,1 > *arg1 = (cv::Matx< uint8_t,3,1 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
SwigValueWrapper< cv::Matx< unsigned char,1,3 > > result;
if (!PyArg_ParseTuple(args,(char *)"O:_Matx_uint8_t_3_1_t",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_unsigned_char_3_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_uint8_t_3_1_t" "', argument " "1"" of type '" "cv::Matx< uint8_t,3,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< uint8_t,3,1 > * >(argp1);
result = ((cv::Matx< uint8_t,3,1 > const *)arg1)->t();
resultobj = SWIG_NewPointerObj((new cv::Matx< unsigned char,1,3 >(static_cast< const cv::Matx< unsigned char,1,3 >& >(result))), SWIGTYPE_p_cv__MatxT_unsigned_char_1_3_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_uint8_t_3_1_mul(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< uint8_t,3,1 > *arg1 = (cv::Matx< uint8_t,3,1 > *) 0 ;
cv::Matx< unsigned char,3,1 > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
SwigValueWrapper< cv::Matx< unsigned char,3,1 > > result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_uint8_t_3_1_mul",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_unsigned_char_3_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_uint8_t_3_1_mul" "', argument " "1"" of type '" "cv::Matx< uint8_t,3,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< uint8_t,3,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_unsigned_char_3_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_uint8_t_3_1_mul" "', argument " "2"" of type '" "cv::Matx< unsigned char,3,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Matx_uint8_t_3_1_mul" "', argument " "2"" of type '" "cv::Matx< unsigned char,3,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< unsigned char,3,1 > * >(argp2);
result = ((cv::Matx< uint8_t,3,1 > const *)arg1)->mul((cv::Matx< unsigned char,3,1 > const &)*arg2);
resultobj = SWIG_NewPointerObj((new cv::Matx< unsigned char,3,1 >(static_cast< const cv::Matx< unsigned char,3,1 >& >(result))), SWIGTYPE_p_cv__MatxT_unsigned_char_3_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_uint8_t_3_1_div(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< uint8_t,3,1 > *arg1 = (cv::Matx< uint8_t,3,1 > *) 0 ;
cv::Matx< unsigned char,3,1 > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
SwigValueWrapper< cv::Matx< unsigned char,3,1 > > result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_uint8_t_3_1_div",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_unsigned_char_3_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_uint8_t_3_1_div" "', argument " "1"" of type '" "cv::Matx< uint8_t,3,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< uint8_t,3,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_unsigned_char_3_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_uint8_t_3_1_div" "', argument " "2"" of type '" "cv::Matx< unsigned char,3,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Matx_uint8_t_3_1_div" "', argument " "2"" of type '" "cv::Matx< unsigned char,3,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< unsigned char,3,1 > * >(argp2);
result = ((cv::Matx< uint8_t,3,1 > const *)arg1)->div((cv::Matx< unsigned char,3,1 > const &)*arg2);
resultobj = SWIG_NewPointerObj((new cv::Matx< unsigned char,3,1 >(static_cast< const cv::Matx< unsigned char,3,1 >& >(result))), SWIGTYPE_p_cv__MatxT_unsigned_char_3_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_uint8_t_3_1___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< uint8_t,3,1 > *arg1 = (cv::Matx< uint8_t,3,1 > *) 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 ;
unsigned char *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:_Matx_uint8_t_3_1___call__",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_unsigned_char_3_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_uint8_t_3_1___call__" "', argument " "1"" of type '" "cv::Matx< uint8_t,3,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< uint8_t,3,1 > * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_Matx_uint8_t_3_1___call__" "', 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 '" "_Matx_uint8_t_3_1___call__" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
result = (unsigned char *) &((cv::Matx< uint8_t,3,1 > const *)arg1)->operator ()(arg2,arg3);
resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(*result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_uint8_t_3_1__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< unsigned char,3,1 > *arg1 = 0 ;
cv::Matx< unsigned char,3,1 > *arg2 = 0 ;
cv::Matx_AddOp 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 ;
cv::Matx< uint8_t,3,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Matx_uint8_t_3_1",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_unsigned_char_3_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_uint8_t_3_1" "', argument " "1"" of type '" "cv::Matx< unsigned char,3,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_uint8_t_3_1" "', argument " "1"" of type '" "cv::Matx< unsigned char,3,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< unsigned char,3,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_unsigned_char_3_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Matx_uint8_t_3_1" "', argument " "2"" of type '" "cv::Matx< unsigned char,3,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_uint8_t_3_1" "', argument " "2"" of type '" "cv::Matx< unsigned char,3,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< unsigned char,3,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_AddOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Matx_uint8_t_3_1" "', argument " "3"" of type '" "cv::Matx_AddOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_uint8_t_3_1" "', argument " "3"" of type '" "cv::Matx_AddOp""'");
} else {
cv::Matx_AddOp * temp = reinterpret_cast< cv::Matx_AddOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Matx< uint8_t,3,1 > *)new cv::Matx< uint8_t,3,1 >((cv::Matx< unsigned char,3,1 > const &)*arg1,(cv::Matx< unsigned char,3,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_unsigned_char_3_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_uint8_t_3_1__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< unsigned char,3,1 > *arg1 = 0 ;
cv::Matx< unsigned char,3,1 > *arg2 = 0 ;
cv::Matx_SubOp 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 ;
cv::Matx< uint8_t,3,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Matx_uint8_t_3_1",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_unsigned_char_3_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_uint8_t_3_1" "', argument " "1"" of type '" "cv::Matx< unsigned char,3,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_uint8_t_3_1" "', argument " "1"" of type '" "cv::Matx< unsigned char,3,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< unsigned char,3,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_unsigned_char_3_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Matx_uint8_t_3_1" "', argument " "2"" of type '" "cv::Matx< unsigned char,3,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_uint8_t_3_1" "', argument " "2"" of type '" "cv::Matx< unsigned char,3,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< unsigned char,3,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_SubOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Matx_uint8_t_3_1" "', argument " "3"" of type '" "cv::Matx_SubOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_uint8_t_3_1" "', argument " "3"" of type '" "cv::Matx_SubOp""'");
} else {
cv::Matx_SubOp * temp = reinterpret_cast< cv::Matx_SubOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Matx< uint8_t,3,1 > *)new cv::Matx< uint8_t,3,1 >((cv::Matx< unsigned char,3,1 > const &)*arg1,(cv::Matx< unsigned char,3,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_unsigned_char_3_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_uint8_t_3_1__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< unsigned char,3,1 > *arg1 = 0 ;
cv::Matx< unsigned char,3,1 > *arg2 = 0 ;
cv::Matx_MulOp 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 ;
cv::Matx< uint8_t,3,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Matx_uint8_t_3_1",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_unsigned_char_3_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_uint8_t_3_1" "', argument " "1"" of type '" "cv::Matx< unsigned char,3,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_uint8_t_3_1" "', argument " "1"" of type '" "cv::Matx< unsigned char,3,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< unsigned char,3,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_unsigned_char_3_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Matx_uint8_t_3_1" "', argument " "2"" of type '" "cv::Matx< unsigned char,3,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_uint8_t_3_1" "', argument " "2"" of type '" "cv::Matx< unsigned char,3,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< unsigned char,3,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_MulOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Matx_uint8_t_3_1" "', argument " "3"" of type '" "cv::Matx_MulOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_uint8_t_3_1" "', argument " "3"" of type '" "cv::Matx_MulOp""'");
} else {
cv::Matx_MulOp * temp = reinterpret_cast< cv::Matx_MulOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Matx< uint8_t,3,1 > *)new cv::Matx< uint8_t,3,1 >((cv::Matx< unsigned char,3,1 > const &)*arg1,(cv::Matx< unsigned char,3,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_unsigned_char_3_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_uint8_t_3_1__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< unsigned char,3,1 > *arg1 = 0 ;
cv::Matx< unsigned char,3,1 > *arg2 = 0 ;
cv::Matx_DivOp 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 ;
cv::Matx< uint8_t,3,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Matx_uint8_t_3_1",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_unsigned_char_3_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_uint8_t_3_1" "', argument " "1"" of type '" "cv::Matx< unsigned char,3,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_uint8_t_3_1" "', argument " "1"" of type '" "cv::Matx< unsigned char,3,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< unsigned char,3,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_unsigned_char_3_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Matx_uint8_t_3_1" "', argument " "2"" of type '" "cv::Matx< unsigned char,3,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_uint8_t_3_1" "', argument " "2"" of type '" "cv::Matx< unsigned char,3,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< unsigned char,3,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_DivOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Matx_uint8_t_3_1" "', argument " "3"" of type '" "cv::Matx_DivOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_uint8_t_3_1" "', argument " "3"" of type '" "cv::Matx_DivOp""'");
} else {
cv::Matx_DivOp * temp = reinterpret_cast< cv::Matx_DivOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Matx< uint8_t,3,1 > *)new cv::Matx< uint8_t,3,1 >((cv::Matx< unsigned char,3,1 > const &)*arg1,(cv::Matx< unsigned char,3,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_unsigned_char_3_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_uint8_t_3_1__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< unsigned char,1,3 > *arg1 = 0 ;
cv::Matx_TOp arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
cv::Matx< uint8_t,3,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:new__Matx_uint8_t_3_1",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_unsigned_char_1_3_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_uint8_t_3_1" "', argument " "1"" of type '" "cv::Matx< unsigned char,1,3 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_uint8_t_3_1" "', argument " "1"" of type '" "cv::Matx< unsigned char,1,3 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< unsigned char,1,3 > * >(argp1);
{
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__Matx_TOp, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Matx_uint8_t_3_1" "', argument " "2"" of type '" "cv::Matx_TOp""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_uint8_t_3_1" "', argument " "2"" of type '" "cv::Matx_TOp""'");
} else {
cv::Matx_TOp * temp = reinterpret_cast< cv::Matx_TOp * >(argp2);
arg2 = *temp;
if (SWIG_IsNewObj(res2)) delete temp;
}
}
result = (cv::Matx< uint8_t,3,1 > *)new cv::Matx< uint8_t,3,1 >((cv::Matx< unsigned char,1,3 > const &)*arg1,arg2);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_unsigned_char_3_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_uint8_t_3_1_val_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< uint8_t,3,1 > *arg1 = (cv::Matx< uint8_t,3,1 > *) 0 ;
unsigned char *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:_Matx_uint8_t_3_1_val_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_unsigned_char_3_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_uint8_t_3_1_val_set" "', argument " "1"" of type '" "cv::Matx< uint8_t,3,1 > *""'");
}
arg1 = reinterpret_cast< cv::Matx< uint8_t,3,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_uint8_t_3_1_val_set" "', argument " "2"" of type '" "unsigned char [3*1]""'");
}
arg2 = reinterpret_cast< unsigned char * >(argp2);
{
if (arg2) {
size_t ii = 0;
for (; ii < (size_t)3*1; ++ii) *(unsigned char *)&arg1->val[ii] = *((unsigned char *)arg2 + ii);
} else {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""val""' of type '""unsigned char [3*1]""'");
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_uint8_t_3_1_val_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< uint8_t,3,1 > *arg1 = (cv::Matx< uint8_t,3,1 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
unsigned char *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:_Matx_uint8_t_3_1_val_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_unsigned_char_3_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_uint8_t_3_1_val_get" "', argument " "1"" of type '" "cv::Matx< uint8_t,3,1 > *""'");
}
arg1 = reinterpret_cast< cv::Matx< uint8_t,3,1 > * >(argp1);
result = (unsigned char *)(unsigned char *) ((arg1)->val);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_uint8_t_3_1__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< cv::Matx< unsigned char,3,1 >::value_type,std::allocator< cv::Matx< uint8_t,3,1 >::value_type > > arg1 ;
PyObject * obj0 = 0 ;
cv::Matx< uint8_t,3,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__Matx_uint8_t_3_1",&obj0)) SWIG_fail;
{
std::vector< unsigned char,std::allocator< unsigned char > > *ptr = (std::vector< unsigned char,std::allocator< unsigned char > > *)0;
int res = swig::asptr(obj0, &ptr);
if (!SWIG_IsOK(res) || !ptr) {
SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new__Matx_uint8_t_3_1" "', argument " "1"" of type '" "std::vector< cv::Matx< unsigned char,3,1 >::value_type,std::allocator< cv::Matx< uint8_t,3,1 >::value_type > >""'");
}
arg1 = *ptr;
if (SWIG_IsNewObj(res)) delete ptr;
}
result = (cv::Matx< uint8_t,3,1 > *)new_cv_Matx_Sl_uint8_t_Sc_3_Sc_1_Sg___SWIG_6(arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_unsigned_char_3_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_uint8_t_3_1(PyObject *self, PyObject *args) {
Py_ssize_t argc;
PyObject *argv[4] = {
0
};
Py_ssize_t ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = args ? PyObject_Length(args) : 0;
for (ii = 0; (ii < 3) && (ii < argc); 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_unsigned_char, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_uint8_t_3_1__SWIG_0(self, args);
}
}
if (argc == 1) {
int _v;
int res = swig::asptr(argv[0], (std::vector< unsigned char,std::allocator< unsigned char > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_uint8_t_3_1__SWIG_6(self, args);
}
}
if (argc == 2) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_unsigned_char_1_3_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__Matx_TOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_uint8_t_3_1__SWIG_5(self, args);
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_unsigned_char_3_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_unsigned_char_3_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_MulOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_uint8_t_3_1__SWIG_3(self, args);
}
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_unsigned_char_3_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_unsigned_char_3_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_DivOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_uint8_t_3_1__SWIG_4(self, args);
}
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_unsigned_char_3_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_unsigned_char_3_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_AddOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_uint8_t_3_1__SWIG_1(self, args);
}
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_unsigned_char_3_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_unsigned_char_3_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_SubOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_uint8_t_3_1__SWIG_2(self, args);
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new__Matx_uint8_t_3_1'.\n"
" Possible C/C++ prototypes are:\n"
" cv::Matx< uint8_t,3,1 >::Matx(unsigned char const *)\n"
" cv::Matx< uint8_t,3,1 >::Matx(cv::Matx< unsigned char,3,1 > const &,cv::Matx< unsigned char,3,1 > const &,cv::Matx_AddOp)\n"
" cv::Matx< uint8_t,3,1 >::Matx(cv::Matx< unsigned char,3,1 > const &,cv::Matx< unsigned char,3,1 > const &,cv::Matx_SubOp)\n"
" cv::Matx< uint8_t,3,1 >::Matx(cv::Matx< unsigned char,3,1 > const &,cv::Matx< unsigned char,3,1 > const &,cv::Matx_MulOp)\n"
" cv::Matx< uint8_t,3,1 >::Matx(cv::Matx< unsigned char,3,1 > const &,cv::Matx< unsigned char,3,1 > const &,cv::Matx_DivOp)\n"
" cv::Matx< uint8_t,3,1 >::Matx(cv::Matx< unsigned char,1,3 > const &,cv::Matx_TOp)\n"
" cv::Matx< uint8_t,3,1 >::Matx(std::vector< cv::Matx< unsigned char,3,1 >::value_type,std::allocator< cv::Matx< uint8_t,3,1 >::value_type > >)\n");
return 0;
}
SWIGINTERN PyObject *_wrap__Matx_uint8_t_3_1___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< uint8_t,3,1 > *arg1 = (cv::Matx< uint8_t,3,1 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
std::string result;
if (!PyArg_ParseTuple(args,(char *)"O:_Matx_uint8_t_3_1___str__",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_unsigned_char_3_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_uint8_t_3_1___str__" "', argument " "1"" of type '" "cv::Matx< uint8_t,3,1 > *""'");
}
arg1 = reinterpret_cast< cv::Matx< uint8_t,3,1 > * >(argp1);
result = cv_Matx_Sl_uint8_t_Sc_3_Sc_1_Sg____str__(arg1);
resultobj = SWIG_From_std_string(static_cast< std::string >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete__Matx_uint8_t_3_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< uint8_t,3,1 > *arg1 = (cv::Matx< uint8_t,3,1 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete__Matx_uint8_t_3_1",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_unsigned_char_3_1_t, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__Matx_uint8_t_3_1" "', argument " "1"" of type '" "cv::Matx< uint8_t,3,1 > *""'");
}
arg1 = reinterpret_cast< cv::Matx< uint8_t,3,1 > * >(argp1);
delete arg1;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_Matx_uint8_t_3_1_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_cv__MatxT_unsigned_char_3_1_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_new__Vec_uint8_t_3__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
unsigned char *arg1 = (unsigned char *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
cv::Vec< uint8_t,3 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__Vec_uint8_t_3",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_unsigned_char, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Vec_uint8_t_3" "', argument " "1"" of type '" "unsigned char const *""'");
}
arg1 = reinterpret_cast< unsigned char * >(argp1);
result = (cv::Vec< uint8_t,3 > *)new cv::Vec< uint8_t,3 >((unsigned char const *)arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__VecT_unsigned_char_3_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Vec_uint8_t_3__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Vec< unsigned char,3 > *arg1 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
cv::Vec< uint8_t,3 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__Vec_uint8_t_3",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__VecT_unsigned_char_3_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Vec_uint8_t_3" "', argument " "1"" of type '" "cv::Vec< unsigned char,3 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_uint8_t_3" "', argument " "1"" of type '" "cv::Vec< unsigned char,3 > const &""'");
}
arg1 = reinterpret_cast< cv::Vec< unsigned char,3 > * >(argp1);
result = (cv::Vec< uint8_t,3 > *)new cv::Vec< uint8_t,3 >((cv::Vec< unsigned char,3 > const &)*arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__VecT_unsigned_char_3_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Vec_uint8_t_3_all(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
unsigned char arg1 ;
unsigned char val1 ;
int ecode1 = 0 ;
PyObject * obj0 = 0 ;
SwigValueWrapper< cv::Vec< unsigned char,3 > > result;
if (!PyArg_ParseTuple(args,(char *)"O:_Vec_uint8_t_3_all",&obj0)) SWIG_fail;
ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_Vec_uint8_t_3_all" "', argument " "1"" of type '" "unsigned char""'");
}
arg1 = static_cast< unsigned char >(val1);
result = cv::Vec< uint8_t,3 >::SWIGTEMPLATEDISAMBIGUATOR all(arg1);
resultobj = SWIG_NewPointerObj((new cv::Vec< uint8_t,3 >(static_cast< const cv::Vec< uint8_t,3 >& >(result))), SWIGTYPE_p_cv__VecT_unsigned_char_3_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Vec_uint8_t_3_mul(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Vec< uint8_t,3 > *arg1 = (cv::Vec< uint8_t,3 > *) 0 ;
cv::Vec< unsigned char,3 > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
SwigValueWrapper< cv::Vec< unsigned char,3 > > result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Vec_uint8_t_3_mul",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__VecT_unsigned_char_3_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Vec_uint8_t_3_mul" "', argument " "1"" of type '" "cv::Vec< uint8_t,3 > const *""'");
}
arg1 = reinterpret_cast< cv::Vec< uint8_t,3 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__VecT_unsigned_char_3_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Vec_uint8_t_3_mul" "', argument " "2"" of type '" "cv::Vec< unsigned char,3 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Vec_uint8_t_3_mul" "', argument " "2"" of type '" "cv::Vec< unsigned char,3 > const &""'");
}
arg2 = reinterpret_cast< cv::Vec< unsigned char,3 > * >(argp2);
result = ((cv::Vec< uint8_t,3 > const *)arg1)->mul((cv::Vec< unsigned char,3 > const &)*arg2);
resultobj = SWIG_NewPointerObj((new cv::Vec< uint8_t,3 >(static_cast< const cv::Vec< uint8_t,3 >& >(result))), SWIGTYPE_p_cv__VecT_unsigned_char_3_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Vec_uint8_t_3___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Vec< uint8_t,3 > *arg1 = (cv::Vec< uint8_t,3 > *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
unsigned char *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:_Vec_uint8_t_3___call__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__VecT_unsigned_char_3_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Vec_uint8_t_3___call__" "', argument " "1"" of type '" "cv::Vec< uint8_t,3 > const *""'");
}
arg1 = reinterpret_cast< cv::Vec< uint8_t,3 > * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_Vec_uint8_t_3___call__" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
result = (unsigned char *) &((cv::Vec< uint8_t,3 > const *)arg1)->operator ()(arg2);
resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(*result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Vec_uint8_t_3__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< unsigned char,3,1 > *arg1 = 0 ;
cv::Matx< unsigned char,3,1 > *arg2 = 0 ;
cv::Matx_AddOp 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 ;
cv::Vec< uint8_t,3 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Vec_uint8_t_3",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_unsigned_char_3_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Vec_uint8_t_3" "', argument " "1"" of type '" "cv::Matx< unsigned char,3,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_uint8_t_3" "', argument " "1"" of type '" "cv::Matx< unsigned char,3,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< unsigned char,3,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_unsigned_char_3_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Vec_uint8_t_3" "', argument " "2"" of type '" "cv::Matx< unsigned char,3,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_uint8_t_3" "', argument " "2"" of type '" "cv::Matx< unsigned char,3,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< unsigned char,3,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_AddOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Vec_uint8_t_3" "', argument " "3"" of type '" "cv::Matx_AddOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_uint8_t_3" "', argument " "3"" of type '" "cv::Matx_AddOp""'");
} else {
cv::Matx_AddOp * temp = reinterpret_cast< cv::Matx_AddOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Vec< uint8_t,3 > *)new cv::Vec< uint8_t,3 >((cv::Matx< unsigned char,3,1 > const &)*arg1,(cv::Matx< unsigned char,3,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__VecT_unsigned_char_3_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Vec_uint8_t_3__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< unsigned char,3,1 > *arg1 = 0 ;
cv::Matx< unsigned char,3,1 > *arg2 = 0 ;
cv::Matx_SubOp 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 ;
cv::Vec< uint8_t,3 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Vec_uint8_t_3",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_unsigned_char_3_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Vec_uint8_t_3" "', argument " "1"" of type '" "cv::Matx< unsigned char,3,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_uint8_t_3" "', argument " "1"" of type '" "cv::Matx< unsigned char,3,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< unsigned char,3,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_unsigned_char_3_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Vec_uint8_t_3" "', argument " "2"" of type '" "cv::Matx< unsigned char,3,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_uint8_t_3" "', argument " "2"" of type '" "cv::Matx< unsigned char,3,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< unsigned char,3,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_SubOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Vec_uint8_t_3" "', argument " "3"" of type '" "cv::Matx_SubOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_uint8_t_3" "', argument " "3"" of type '" "cv::Matx_SubOp""'");
} else {
cv::Matx_SubOp * temp = reinterpret_cast< cv::Matx_SubOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Vec< uint8_t,3 > *)new cv::Vec< uint8_t,3 >((cv::Matx< unsigned char,3,1 > const &)*arg1,(cv::Matx< unsigned char,3,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__VecT_unsigned_char_3_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Vec_uint8_t_3__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< cv::Vec< unsigned char,3 >::value_type,std::allocator< cv::Vec< uint8_t,3 >::value_type > > arg1 ;
PyObject * obj0 = 0 ;
cv::Vec< uint8_t,3 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__Vec_uint8_t_3",&obj0)) SWIG_fail;
{
std::vector< unsigned char,std::allocator< unsigned char > > *ptr = (std::vector< unsigned char,std::allocator< unsigned char > > *)0;
int res = swig::asptr(obj0, &ptr);
if (!SWIG_IsOK(res) || !ptr) {
SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new__Vec_uint8_t_3" "', argument " "1"" of type '" "std::vector< cv::Vec< unsigned char,3 >::value_type,std::allocator< cv::Vec< uint8_t,3 >::value_type > >""'");
}
arg1 = *ptr;
if (SWIG_IsNewObj(res)) delete ptr;
}
result = (cv::Vec< uint8_t,3 > *)new_cv_Vec_Sl_uint8_t_Sc_3_Sg___SWIG_4(arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__VecT_unsigned_char_3_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Vec_uint8_t_3(PyObject *self, PyObject *args) {
Py_ssize_t argc;
PyObject *argv[4] = {
0
};
Py_ssize_t ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = args ? PyObject_Length(args) : 0;
for (ii = 0; (ii < 3) && (ii < argc); 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_unsigned_char, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Vec_uint8_t_3__SWIG_0(self, args);
}
}
if (argc == 1) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__VecT_unsigned_char_3_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Vec_uint8_t_3__SWIG_1(self, args);
}
}
if (argc == 1) {
int _v;
int res = swig::asptr(argv[0], (std::vector< unsigned char,std::allocator< unsigned char > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Vec_uint8_t_3__SWIG_4(self, args);
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_unsigned_char_3_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_unsigned_char_3_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_SubOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Vec_uint8_t_3__SWIG_3(self, args);
}
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_unsigned_char_3_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_unsigned_char_3_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_AddOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Vec_uint8_t_3__SWIG_2(self, args);
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new__Vec_uint8_t_3'.\n"
" Possible C/C++ prototypes are:\n"
" cv::Vec< uint8_t,3 >::Vec(unsigned char const *)\n"
" cv::Vec< uint8_t,3 >::Vec(cv::Vec< unsigned char,3 > const &)\n"
" cv::Vec< uint8_t,3 >::Vec(cv::Matx< unsigned char,3,1 > const &,cv::Matx< unsigned char,3,1 > const &,cv::Matx_AddOp)\n"
" cv::Vec< uint8_t,3 >::Vec(cv::Matx< unsigned char,3,1 > const &,cv::Matx< unsigned char,3,1 > const &,cv::Matx_SubOp)\n"
" cv::Vec< uint8_t,3 >::Vec(std::vector< cv::Vec< unsigned char,3 >::value_type,std::allocator< cv::Vec< uint8_t,3 >::value_type > >)\n");
return 0;
}
SWIGINTERN PyObject *_wrap__Vec_uint8_t_3___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Vec< uint8_t,3 > *arg1 = (cv::Vec< uint8_t,3 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
std::string result;
if (!PyArg_ParseTuple(args,(char *)"O:_Vec_uint8_t_3___str__",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__VecT_unsigned_char_3_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Vec_uint8_t_3___str__" "', argument " "1"" of type '" "cv::Vec< uint8_t,3 > *""'");
}
arg1 = reinterpret_cast< cv::Vec< uint8_t,3 > * >(argp1);
result = cv_Vec_Sl_uint8_t_Sc_3_Sg____str__(arg1);
resultobj = SWIG_From_std_string(static_cast< std::string >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete__Vec_uint8_t_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Vec< uint8_t,3 > *arg1 = (cv::Vec< uint8_t,3 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete__Vec_uint8_t_3",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__VecT_unsigned_char_3_t, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__Vec_uint8_t_3" "', argument " "1"" of type '" "cv::Vec< uint8_t,3 > *""'");
}
arg1 = reinterpret_cast< cv::Vec< uint8_t,3 > * >(argp1);
delete arg1;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_Vec_uint8_t_3_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_cv__VecT_unsigned_char_3_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_new__DataType_Vec_uint8_t_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::DataType< cv::Vec< uint8_t,3 > > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new__DataType_Vec_uint8_t_3")) SWIG_fail;
result = (cv::DataType< cv::Vec< uint8_t,3 > > *)new cv::DataType< cv::Vec< uint8_t,3 > >();
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__DataTypeT_cv__VecT_uint8_t_3_t_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete__DataType_Vec_uint8_t_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::DataType< cv::Vec< uint8_t,3 > > *arg1 = (cv::DataType< cv::Vec< uint8_t,3 > > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete__DataType_Vec_uint8_t_3",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__DataTypeT_cv__VecT_uint8_t_3_t_t, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__DataType_Vec_uint8_t_3" "', argument " "1"" of type '" "cv::DataType< cv::Vec< uint8_t,3 > > *""'");
}
arg1 = reinterpret_cast< cv::DataType< cv::Vec< uint8_t,3 > > * >(argp1);
delete arg1;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_DataType_Vec_uint8_t_3_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_cv__DataTypeT_cv__VecT_uint8_t_3_t_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_new__Matx_uint8_t_4_1__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
unsigned char *arg1 = (unsigned char *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
cv::Matx< uint8_t,4,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__Matx_uint8_t_4_1",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_unsigned_char, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_uint8_t_4_1" "', argument " "1"" of type '" "unsigned char const *""'");
}
arg1 = reinterpret_cast< unsigned char * >(argp1);
result = (cv::Matx< uint8_t,4,1 > *)new cv::Matx< uint8_t,4,1 >((unsigned char const *)arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_unsigned_char_4_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_uint8_t_4_1_all(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
unsigned char arg1 ;
unsigned char val1 ;
int ecode1 = 0 ;
PyObject * obj0 = 0 ;
SwigValueWrapper< cv::Matx< unsigned char,4,1 > > result;
if (!PyArg_ParseTuple(args,(char *)"O:_Matx_uint8_t_4_1_all",&obj0)) SWIG_fail;
ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_Matx_uint8_t_4_1_all" "', argument " "1"" of type '" "unsigned char""'");
}
arg1 = static_cast< unsigned char >(val1);
result = cv::Matx< uint8_t,4,1 >::SWIGTEMPLATEDISAMBIGUATOR all(arg1);
resultobj = SWIG_NewPointerObj((new cv::Matx< uint8_t,4,1 >(static_cast< const cv::Matx< uint8_t,4,1 >& >(result))), SWIGTYPE_p_cv__MatxT_unsigned_char_4_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_uint8_t_4_1_zeros(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
SwigValueWrapper< cv::Matx< unsigned char,4,1 > > result;
if (!PyArg_ParseTuple(args,(char *)":_Matx_uint8_t_4_1_zeros")) SWIG_fail;
result = cv::Matx< uint8_t,4,1 >::SWIGTEMPLATEDISAMBIGUATOR zeros();
resultobj = SWIG_NewPointerObj((new cv::Matx< uint8_t,4,1 >(static_cast< const cv::Matx< uint8_t,4,1 >& >(result))), SWIGTYPE_p_cv__MatxT_unsigned_char_4_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_uint8_t_4_1_ones(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
SwigValueWrapper< cv::Matx< unsigned char,4,1 > > result;
if (!PyArg_ParseTuple(args,(char *)":_Matx_uint8_t_4_1_ones")) SWIG_fail;
result = cv::Matx< uint8_t,4,1 >::SWIGTEMPLATEDISAMBIGUATOR ones();
resultobj = SWIG_NewPointerObj((new cv::Matx< uint8_t,4,1 >(static_cast< const cv::Matx< uint8_t,4,1 >& >(result))), SWIGTYPE_p_cv__MatxT_unsigned_char_4_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_uint8_t_4_1_eye(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
SwigValueWrapper< cv::Matx< unsigned char,4,1 > > result;
if (!PyArg_ParseTuple(args,(char *)":_Matx_uint8_t_4_1_eye")) SWIG_fail;
result = cv::Matx< uint8_t,4,1 >::SWIGTEMPLATEDISAMBIGUATOR eye();
resultobj = SWIG_NewPointerObj((new cv::Matx< uint8_t,4,1 >(static_cast< const cv::Matx< uint8_t,4,1 >& >(result))), SWIGTYPE_p_cv__MatxT_unsigned_char_4_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_uint8_t_4_1_randu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
unsigned char arg1 ;
unsigned char arg2 ;
unsigned char val1 ;
int ecode1 = 0 ;
unsigned char val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
SwigValueWrapper< cv::Matx< unsigned char,4,1 > > result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_uint8_t_4_1_randu",&obj0,&obj1)) SWIG_fail;
ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_Matx_uint8_t_4_1_randu" "', argument " "1"" of type '" "unsigned char""'");
}
arg1 = static_cast< unsigned char >(val1);
ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_Matx_uint8_t_4_1_randu" "', argument " "2"" of type '" "unsigned char""'");
}
arg2 = static_cast< unsigned char >(val2);
result = cv::Matx< uint8_t,4,1 >::SWIGTEMPLATEDISAMBIGUATOR randu(arg1,arg2);
resultobj = SWIG_NewPointerObj((new cv::Matx< uint8_t,4,1 >(static_cast< const cv::Matx< uint8_t,4,1 >& >(result))), SWIGTYPE_p_cv__MatxT_unsigned_char_4_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_uint8_t_4_1_randn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
unsigned char arg1 ;
unsigned char arg2 ;
unsigned char val1 ;
int ecode1 = 0 ;
unsigned char val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
SwigValueWrapper< cv::Matx< unsigned char,4,1 > > result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_uint8_t_4_1_randn",&obj0,&obj1)) SWIG_fail;
ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_Matx_uint8_t_4_1_randn" "', argument " "1"" of type '" "unsigned char""'");
}
arg1 = static_cast< unsigned char >(val1);
ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_Matx_uint8_t_4_1_randn" "', argument " "2"" of type '" "unsigned char""'");
}
arg2 = static_cast< unsigned char >(val2);
result = cv::Matx< uint8_t,4,1 >::SWIGTEMPLATEDISAMBIGUATOR randn(arg1,arg2);
resultobj = SWIG_NewPointerObj((new cv::Matx< uint8_t,4,1 >(static_cast< const cv::Matx< uint8_t,4,1 >& >(result))), SWIGTYPE_p_cv__MatxT_unsigned_char_4_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_uint8_t_4_1_dot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< uint8_t,4,1 > *arg1 = (cv::Matx< uint8_t,4,1 > *) 0 ;
cv::Matx< unsigned char,4,1 > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
unsigned char result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_uint8_t_4_1_dot",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_unsigned_char_4_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_uint8_t_4_1_dot" "', argument " "1"" of type '" "cv::Matx< uint8_t,4,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< uint8_t,4,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_unsigned_char_4_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_uint8_t_4_1_dot" "', argument " "2"" of type '" "cv::Matx< unsigned char,4,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Matx_uint8_t_4_1_dot" "', argument " "2"" of type '" "cv::Matx< unsigned char,4,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< unsigned char,4,1 > * >(argp2);
result = (unsigned char)((cv::Matx< uint8_t,4,1 > const *)arg1)->dot((cv::Matx< unsigned char,4,1 > const &)*arg2);
resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_uint8_t_4_1_ddot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< uint8_t,4,1 > *arg1 = (cv::Matx< uint8_t,4,1 > *) 0 ;
cv::Matx< unsigned char,4,1 > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
double result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_uint8_t_4_1_ddot",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_unsigned_char_4_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_uint8_t_4_1_ddot" "', argument " "1"" of type '" "cv::Matx< uint8_t,4,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< uint8_t,4,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_unsigned_char_4_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_uint8_t_4_1_ddot" "', argument " "2"" of type '" "cv::Matx< unsigned char,4,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Matx_uint8_t_4_1_ddot" "', argument " "2"" of type '" "cv::Matx< unsigned char,4,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< unsigned char,4,1 > * >(argp2);
result = (double)((cv::Matx< uint8_t,4,1 > const *)arg1)->ddot((cv::Matx< unsigned char,4,1 > const &)*arg2);
resultobj = SWIG_From_double(static_cast< double >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_uint8_t_4_1_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< uint8_t,4,1 > *arg1 = (cv::Matx< uint8_t,4,1 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
SwigValueWrapper< cv::Matx< unsigned char,1,4 > > result;
if (!PyArg_ParseTuple(args,(char *)"O:_Matx_uint8_t_4_1_t",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_unsigned_char_4_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_uint8_t_4_1_t" "', argument " "1"" of type '" "cv::Matx< uint8_t,4,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< uint8_t,4,1 > * >(argp1);
result = ((cv::Matx< uint8_t,4,1 > const *)arg1)->t();
resultobj = SWIG_NewPointerObj((new cv::Matx< unsigned char,1,4 >(static_cast< const cv::Matx< unsigned char,1,4 >& >(result))), SWIGTYPE_p_cv__MatxT_unsigned_char_1_4_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_uint8_t_4_1_mul(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< uint8_t,4,1 > *arg1 = (cv::Matx< uint8_t,4,1 > *) 0 ;
cv::Matx< unsigned char,4,1 > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
SwigValueWrapper< cv::Matx< unsigned char,4,1 > > result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_uint8_t_4_1_mul",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_unsigned_char_4_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_uint8_t_4_1_mul" "', argument " "1"" of type '" "cv::Matx< uint8_t,4,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< uint8_t,4,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_unsigned_char_4_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_uint8_t_4_1_mul" "', argument " "2"" of type '" "cv::Matx< unsigned char,4,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Matx_uint8_t_4_1_mul" "', argument " "2"" of type '" "cv::Matx< unsigned char,4,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< unsigned char,4,1 > * >(argp2);
result = ((cv::Matx< uint8_t,4,1 > const *)arg1)->mul((cv::Matx< unsigned char,4,1 > const &)*arg2);
resultobj = SWIG_NewPointerObj((new cv::Matx< unsigned char,4,1 >(static_cast< const cv::Matx< unsigned char,4,1 >& >(result))), SWIGTYPE_p_cv__MatxT_unsigned_char_4_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_uint8_t_4_1_div(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< uint8_t,4,1 > *arg1 = (cv::Matx< uint8_t,4,1 > *) 0 ;
cv::Matx< unsigned char,4,1 > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
SwigValueWrapper< cv::Matx< unsigned char,4,1 > > result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_uint8_t_4_1_div",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_unsigned_char_4_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_uint8_t_4_1_div" "', argument " "1"" of type '" "cv::Matx< uint8_t,4,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< uint8_t,4,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_unsigned_char_4_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_uint8_t_4_1_div" "', argument " "2"" of type '" "cv::Matx< unsigned char,4,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Matx_uint8_t_4_1_div" "', argument " "2"" of type '" "cv::Matx< unsigned char,4,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< unsigned char,4,1 > * >(argp2);
result = ((cv::Matx< uint8_t,4,1 > const *)arg1)->div((cv::Matx< unsigned char,4,1 > const &)*arg2);
resultobj = SWIG_NewPointerObj((new cv::Matx< unsigned char,4,1 >(static_cast< const cv::Matx< unsigned char,4,1 >& >(result))), SWIGTYPE_p_cv__MatxT_unsigned_char_4_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_uint8_t_4_1___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< uint8_t,4,1 > *arg1 = (cv::Matx< uint8_t,4,1 > *) 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 ;
unsigned char *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:_Matx_uint8_t_4_1___call__",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_unsigned_char_4_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_uint8_t_4_1___call__" "', argument " "1"" of type '" "cv::Matx< uint8_t,4,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< uint8_t,4,1 > * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_Matx_uint8_t_4_1___call__" "', 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 '" "_Matx_uint8_t_4_1___call__" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
result = (unsigned char *) &((cv::Matx< uint8_t,4,1 > const *)arg1)->operator ()(arg2,arg3);
resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(*result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_uint8_t_4_1__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< unsigned char,4,1 > *arg1 = 0 ;
cv::Matx< unsigned char,4,1 > *arg2 = 0 ;
cv::Matx_AddOp 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 ;
cv::Matx< uint8_t,4,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Matx_uint8_t_4_1",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_unsigned_char_4_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_uint8_t_4_1" "', argument " "1"" of type '" "cv::Matx< unsigned char,4,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_uint8_t_4_1" "', argument " "1"" of type '" "cv::Matx< unsigned char,4,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< unsigned char,4,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_unsigned_char_4_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Matx_uint8_t_4_1" "', argument " "2"" of type '" "cv::Matx< unsigned char,4,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_uint8_t_4_1" "', argument " "2"" of type '" "cv::Matx< unsigned char,4,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< unsigned char,4,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_AddOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Matx_uint8_t_4_1" "', argument " "3"" of type '" "cv::Matx_AddOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_uint8_t_4_1" "', argument " "3"" of type '" "cv::Matx_AddOp""'");
} else {
cv::Matx_AddOp * temp = reinterpret_cast< cv::Matx_AddOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Matx< uint8_t,4,1 > *)new cv::Matx< uint8_t,4,1 >((cv::Matx< unsigned char,4,1 > const &)*arg1,(cv::Matx< unsigned char,4,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_unsigned_char_4_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_uint8_t_4_1__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< unsigned char,4,1 > *arg1 = 0 ;
cv::Matx< unsigned char,4,1 > *arg2 = 0 ;
cv::Matx_SubOp 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 ;
cv::Matx< uint8_t,4,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Matx_uint8_t_4_1",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_unsigned_char_4_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_uint8_t_4_1" "', argument " "1"" of type '" "cv::Matx< unsigned char,4,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_uint8_t_4_1" "', argument " "1"" of type '" "cv::Matx< unsigned char,4,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< unsigned char,4,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_unsigned_char_4_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Matx_uint8_t_4_1" "', argument " "2"" of type '" "cv::Matx< unsigned char,4,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_uint8_t_4_1" "', argument " "2"" of type '" "cv::Matx< unsigned char,4,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< unsigned char,4,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_SubOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Matx_uint8_t_4_1" "', argument " "3"" of type '" "cv::Matx_SubOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_uint8_t_4_1" "', argument " "3"" of type '" "cv::Matx_SubOp""'");
} else {
cv::Matx_SubOp * temp = reinterpret_cast< cv::Matx_SubOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Matx< uint8_t,4,1 > *)new cv::Matx< uint8_t,4,1 >((cv::Matx< unsigned char,4,1 > const &)*arg1,(cv::Matx< unsigned char,4,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_unsigned_char_4_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_uint8_t_4_1__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< unsigned char,4,1 > *arg1 = 0 ;
cv::Matx< unsigned char,4,1 > *arg2 = 0 ;
cv::Matx_MulOp 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 ;
cv::Matx< uint8_t,4,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Matx_uint8_t_4_1",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_unsigned_char_4_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_uint8_t_4_1" "', argument " "1"" of type '" "cv::Matx< unsigned char,4,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_uint8_t_4_1" "', argument " "1"" of type '" "cv::Matx< unsigned char,4,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< unsigned char,4,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_unsigned_char_4_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Matx_uint8_t_4_1" "', argument " "2"" of type '" "cv::Matx< unsigned char,4,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_uint8_t_4_1" "', argument " "2"" of type '" "cv::Matx< unsigned char,4,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< unsigned char,4,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_MulOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Matx_uint8_t_4_1" "', argument " "3"" of type '" "cv::Matx_MulOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_uint8_t_4_1" "', argument " "3"" of type '" "cv::Matx_MulOp""'");
} else {
cv::Matx_MulOp * temp = reinterpret_cast< cv::Matx_MulOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Matx< uint8_t,4,1 > *)new cv::Matx< uint8_t,4,1 >((cv::Matx< unsigned char,4,1 > const &)*arg1,(cv::Matx< unsigned char,4,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_unsigned_char_4_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_uint8_t_4_1__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< unsigned char,4,1 > *arg1 = 0 ;
cv::Matx< unsigned char,4,1 > *arg2 = 0 ;
cv::Matx_DivOp 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 ;
cv::Matx< uint8_t,4,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Matx_uint8_t_4_1",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_unsigned_char_4_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_uint8_t_4_1" "', argument " "1"" of type '" "cv::Matx< unsigned char,4,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_uint8_t_4_1" "', argument " "1"" of type '" "cv::Matx< unsigned char,4,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< unsigned char,4,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_unsigned_char_4_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Matx_uint8_t_4_1" "', argument " "2"" of type '" "cv::Matx< unsigned char,4,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_uint8_t_4_1" "', argument " "2"" of type '" "cv::Matx< unsigned char,4,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< unsigned char,4,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_DivOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Matx_uint8_t_4_1" "', argument " "3"" of type '" "cv::Matx_DivOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_uint8_t_4_1" "', argument " "3"" of type '" "cv::Matx_DivOp""'");
} else {
cv::Matx_DivOp * temp = reinterpret_cast< cv::Matx_DivOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Matx< uint8_t,4,1 > *)new cv::Matx< uint8_t,4,1 >((cv::Matx< unsigned char,4,1 > const &)*arg1,(cv::Matx< unsigned char,4,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_unsigned_char_4_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_uint8_t_4_1__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< unsigned char,1,4 > *arg1 = 0 ;
cv::Matx_TOp arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
cv::Matx< uint8_t,4,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:new__Matx_uint8_t_4_1",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_unsigned_char_1_4_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_uint8_t_4_1" "', argument " "1"" of type '" "cv::Matx< unsigned char,1,4 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_uint8_t_4_1" "', argument " "1"" of type '" "cv::Matx< unsigned char,1,4 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< unsigned char,1,4 > * >(argp1);
{
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__Matx_TOp, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Matx_uint8_t_4_1" "', argument " "2"" of type '" "cv::Matx_TOp""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_uint8_t_4_1" "', argument " "2"" of type '" "cv::Matx_TOp""'");
} else {
cv::Matx_TOp * temp = reinterpret_cast< cv::Matx_TOp * >(argp2);
arg2 = *temp;
if (SWIG_IsNewObj(res2)) delete temp;
}
}
result = (cv::Matx< uint8_t,4,1 > *)new cv::Matx< uint8_t,4,1 >((cv::Matx< unsigned char,1,4 > const &)*arg1,arg2);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_unsigned_char_4_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_uint8_t_4_1_val_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< uint8_t,4,1 > *arg1 = (cv::Matx< uint8_t,4,1 > *) 0 ;
unsigned char *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:_Matx_uint8_t_4_1_val_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_unsigned_char_4_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_uint8_t_4_1_val_set" "', argument " "1"" of type '" "cv::Matx< uint8_t,4,1 > *""'");
}
arg1 = reinterpret_cast< cv::Matx< uint8_t,4,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_uint8_t_4_1_val_set" "', argument " "2"" of type '" "unsigned char [4*1]""'");
}
arg2 = reinterpret_cast< unsigned char * >(argp2);
{
if (arg2) {
size_t ii = 0;
for (; ii < (size_t)4*1; ++ii) *(unsigned char *)&arg1->val[ii] = *((unsigned char *)arg2 + ii);
} else {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""val""' of type '""unsigned char [4*1]""'");
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_uint8_t_4_1_val_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< uint8_t,4,1 > *arg1 = (cv::Matx< uint8_t,4,1 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
unsigned char *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:_Matx_uint8_t_4_1_val_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_unsigned_char_4_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_uint8_t_4_1_val_get" "', argument " "1"" of type '" "cv::Matx< uint8_t,4,1 > *""'");
}
arg1 = reinterpret_cast< cv::Matx< uint8_t,4,1 > * >(argp1);
result = (unsigned char *)(unsigned char *) ((arg1)->val);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_uint8_t_4_1__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< cv::Matx< unsigned char,4,1 >::value_type,std::allocator< cv::Matx< uint8_t,4,1 >::value_type > > arg1 ;
PyObject * obj0 = 0 ;
cv::Matx< uint8_t,4,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__Matx_uint8_t_4_1",&obj0)) SWIG_fail;
{
std::vector< unsigned char,std::allocator< unsigned char > > *ptr = (std::vector< unsigned char,std::allocator< unsigned char > > *)0;
int res = swig::asptr(obj0, &ptr);
if (!SWIG_IsOK(res) || !ptr) {
SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new__Matx_uint8_t_4_1" "', argument " "1"" of type '" "std::vector< cv::Matx< unsigned char,4,1 >::value_type,std::allocator< cv::Matx< uint8_t,4,1 >::value_type > >""'");
}
arg1 = *ptr;
if (SWIG_IsNewObj(res)) delete ptr;
}
result = (cv::Matx< uint8_t,4,1 > *)new_cv_Matx_Sl_uint8_t_Sc_4_Sc_1_Sg___SWIG_6(arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_unsigned_char_4_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_uint8_t_4_1(PyObject *self, PyObject *args) {
Py_ssize_t argc;
PyObject *argv[4] = {
0
};
Py_ssize_t ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = args ? PyObject_Length(args) : 0;
for (ii = 0; (ii < 3) && (ii < argc); 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_unsigned_char, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_uint8_t_4_1__SWIG_0(self, args);
}
}
if (argc == 1) {
int _v;
int res = swig::asptr(argv[0], (std::vector< unsigned char,std::allocator< unsigned char > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_uint8_t_4_1__SWIG_6(self, args);
}
}
if (argc == 2) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_unsigned_char_1_4_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__Matx_TOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_uint8_t_4_1__SWIG_5(self, args);
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_unsigned_char_4_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_unsigned_char_4_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_MulOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_uint8_t_4_1__SWIG_3(self, args);
}
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_unsigned_char_4_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_unsigned_char_4_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_DivOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_uint8_t_4_1__SWIG_4(self, args);
}
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_unsigned_char_4_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_unsigned_char_4_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_AddOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_uint8_t_4_1__SWIG_1(self, args);
}
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_unsigned_char_4_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_unsigned_char_4_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_SubOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_uint8_t_4_1__SWIG_2(self, args);
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new__Matx_uint8_t_4_1'.\n"
" Possible C/C++ prototypes are:\n"
" cv::Matx< uint8_t,4,1 >::Matx(unsigned char const *)\n"
" cv::Matx< uint8_t,4,1 >::Matx(cv::Matx< unsigned char,4,1 > const &,cv::Matx< unsigned char,4,1 > const &,cv::Matx_AddOp)\n"
" cv::Matx< uint8_t,4,1 >::Matx(cv::Matx< unsigned char,4,1 > const &,cv::Matx< unsigned char,4,1 > const &,cv::Matx_SubOp)\n"
" cv::Matx< uint8_t,4,1 >::Matx(cv::Matx< unsigned char,4,1 > const &,cv::Matx< unsigned char,4,1 > const &,cv::Matx_MulOp)\n"
" cv::Matx< uint8_t,4,1 >::Matx(cv::Matx< unsigned char,4,1 > const &,cv::Matx< unsigned char,4,1 > const &,cv::Matx_DivOp)\n"
" cv::Matx< uint8_t,4,1 >::Matx(cv::Matx< unsigned char,1,4 > const &,cv::Matx_TOp)\n"
" cv::Matx< uint8_t,4,1 >::Matx(std::vector< cv::Matx< unsigned char,4,1 >::value_type,std::allocator< cv::Matx< uint8_t,4,1 >::value_type > >)\n");
return 0;
}
SWIGINTERN PyObject *_wrap__Matx_uint8_t_4_1___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< uint8_t,4,1 > *arg1 = (cv::Matx< uint8_t,4,1 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
std::string result;
if (!PyArg_ParseTuple(args,(char *)"O:_Matx_uint8_t_4_1___str__",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_unsigned_char_4_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_uint8_t_4_1___str__" "', argument " "1"" of type '" "cv::Matx< uint8_t,4,1 > *""'");
}
arg1 = reinterpret_cast< cv::Matx< uint8_t,4,1 > * >(argp1);
result = cv_Matx_Sl_uint8_t_Sc_4_Sc_1_Sg____str__(arg1);
resultobj = SWIG_From_std_string(static_cast< std::string >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete__Matx_uint8_t_4_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< uint8_t,4,1 > *arg1 = (cv::Matx< uint8_t,4,1 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete__Matx_uint8_t_4_1",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_unsigned_char_4_1_t, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__Matx_uint8_t_4_1" "', argument " "1"" of type '" "cv::Matx< uint8_t,4,1 > *""'");
}
arg1 = reinterpret_cast< cv::Matx< uint8_t,4,1 > * >(argp1);
delete arg1;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_Matx_uint8_t_4_1_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_cv__MatxT_unsigned_char_4_1_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_new__Vec_uint8_t_4__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
unsigned char *arg1 = (unsigned char *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
cv::Vec< uint8_t,4 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__Vec_uint8_t_4",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_unsigned_char, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Vec_uint8_t_4" "', argument " "1"" of type '" "unsigned char const *""'");
}
arg1 = reinterpret_cast< unsigned char * >(argp1);
result = (cv::Vec< uint8_t,4 > *)new cv::Vec< uint8_t,4 >((unsigned char const *)arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__VecT_unsigned_char_4_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Vec_uint8_t_4__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Vec< unsigned char,4 > *arg1 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
cv::Vec< uint8_t,4 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__Vec_uint8_t_4",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__VecT_unsigned_char_4_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Vec_uint8_t_4" "', argument " "1"" of type '" "cv::Vec< unsigned char,4 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_uint8_t_4" "', argument " "1"" of type '" "cv::Vec< unsigned char,4 > const &""'");
}
arg1 = reinterpret_cast< cv::Vec< unsigned char,4 > * >(argp1);
result = (cv::Vec< uint8_t,4 > *)new cv::Vec< uint8_t,4 >((cv::Vec< unsigned char,4 > const &)*arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__VecT_unsigned_char_4_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Vec_uint8_t_4_all(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
unsigned char arg1 ;
unsigned char val1 ;
int ecode1 = 0 ;
PyObject * obj0 = 0 ;
SwigValueWrapper< cv::Vec< unsigned char,4 > > result;
if (!PyArg_ParseTuple(args,(char *)"O:_Vec_uint8_t_4_all",&obj0)) SWIG_fail;
ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_Vec_uint8_t_4_all" "', argument " "1"" of type '" "unsigned char""'");
}
arg1 = static_cast< unsigned char >(val1);
result = cv::Vec< uint8_t,4 >::SWIGTEMPLATEDISAMBIGUATOR all(arg1);
resultobj = SWIG_NewPointerObj((new cv::Vec< uint8_t,4 >(static_cast< const cv::Vec< uint8_t,4 >& >(result))), SWIGTYPE_p_cv__VecT_unsigned_char_4_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Vec_uint8_t_4_mul(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Vec< uint8_t,4 > *arg1 = (cv::Vec< uint8_t,4 > *) 0 ;
cv::Vec< unsigned char,4 > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
SwigValueWrapper< cv::Vec< unsigned char,4 > > result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Vec_uint8_t_4_mul",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__VecT_unsigned_char_4_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Vec_uint8_t_4_mul" "', argument " "1"" of type '" "cv::Vec< uint8_t,4 > const *""'");
}
arg1 = reinterpret_cast< cv::Vec< uint8_t,4 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__VecT_unsigned_char_4_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Vec_uint8_t_4_mul" "', argument " "2"" of type '" "cv::Vec< unsigned char,4 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Vec_uint8_t_4_mul" "', argument " "2"" of type '" "cv::Vec< unsigned char,4 > const &""'");
}
arg2 = reinterpret_cast< cv::Vec< unsigned char,4 > * >(argp2);
result = ((cv::Vec< uint8_t,4 > const *)arg1)->mul((cv::Vec< unsigned char,4 > const &)*arg2);
resultobj = SWIG_NewPointerObj((new cv::Vec< uint8_t,4 >(static_cast< const cv::Vec< uint8_t,4 >& >(result))), SWIGTYPE_p_cv__VecT_unsigned_char_4_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Vec_uint8_t_4___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Vec< uint8_t,4 > *arg1 = (cv::Vec< uint8_t,4 > *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
unsigned char *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:_Vec_uint8_t_4___call__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__VecT_unsigned_char_4_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Vec_uint8_t_4___call__" "', argument " "1"" of type '" "cv::Vec< uint8_t,4 > const *""'");
}
arg1 = reinterpret_cast< cv::Vec< uint8_t,4 > * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_Vec_uint8_t_4___call__" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
result = (unsigned char *) &((cv::Vec< uint8_t,4 > const *)arg1)->operator ()(arg2);
resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(*result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Vec_uint8_t_4__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< unsigned char,4,1 > *arg1 = 0 ;
cv::Matx< unsigned char,4,1 > *arg2 = 0 ;
cv::Matx_AddOp 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 ;
cv::Vec< uint8_t,4 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Vec_uint8_t_4",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_unsigned_char_4_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Vec_uint8_t_4" "', argument " "1"" of type '" "cv::Matx< unsigned char,4,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_uint8_t_4" "', argument " "1"" of type '" "cv::Matx< unsigned char,4,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< unsigned char,4,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_unsigned_char_4_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Vec_uint8_t_4" "', argument " "2"" of type '" "cv::Matx< unsigned char,4,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_uint8_t_4" "', argument " "2"" of type '" "cv::Matx< unsigned char,4,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< unsigned char,4,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_AddOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Vec_uint8_t_4" "', argument " "3"" of type '" "cv::Matx_AddOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_uint8_t_4" "', argument " "3"" of type '" "cv::Matx_AddOp""'");
} else {
cv::Matx_AddOp * temp = reinterpret_cast< cv::Matx_AddOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Vec< uint8_t,4 > *)new cv::Vec< uint8_t,4 >((cv::Matx< unsigned char,4,1 > const &)*arg1,(cv::Matx< unsigned char,4,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__VecT_unsigned_char_4_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Vec_uint8_t_4__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< unsigned char,4,1 > *arg1 = 0 ;
cv::Matx< unsigned char,4,1 > *arg2 = 0 ;
cv::Matx_SubOp 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 ;
cv::Vec< uint8_t,4 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Vec_uint8_t_4",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_unsigned_char_4_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Vec_uint8_t_4" "', argument " "1"" of type '" "cv::Matx< unsigned char,4,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_uint8_t_4" "', argument " "1"" of type '" "cv::Matx< unsigned char,4,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< unsigned char,4,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_unsigned_char_4_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Vec_uint8_t_4" "', argument " "2"" of type '" "cv::Matx< unsigned char,4,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_uint8_t_4" "', argument " "2"" of type '" "cv::Matx< unsigned char,4,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< unsigned char,4,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_SubOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Vec_uint8_t_4" "', argument " "3"" of type '" "cv::Matx_SubOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_uint8_t_4" "', argument " "3"" of type '" "cv::Matx_SubOp""'");
} else {
cv::Matx_SubOp * temp = reinterpret_cast< cv::Matx_SubOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Vec< uint8_t,4 > *)new cv::Vec< uint8_t,4 >((cv::Matx< unsigned char,4,1 > const &)*arg1,(cv::Matx< unsigned char,4,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__VecT_unsigned_char_4_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Vec_uint8_t_4__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< cv::Vec< unsigned char,4 >::value_type,std::allocator< cv::Vec< uint8_t,4 >::value_type > > arg1 ;
PyObject * obj0 = 0 ;
cv::Vec< uint8_t,4 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__Vec_uint8_t_4",&obj0)) SWIG_fail;
{
std::vector< unsigned char,std::allocator< unsigned char > > *ptr = (std::vector< unsigned char,std::allocator< unsigned char > > *)0;
int res = swig::asptr(obj0, &ptr);
if (!SWIG_IsOK(res) || !ptr) {
SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new__Vec_uint8_t_4" "', argument " "1"" of type '" "std::vector< cv::Vec< unsigned char,4 >::value_type,std::allocator< cv::Vec< uint8_t,4 >::value_type > >""'");
}
arg1 = *ptr;
if (SWIG_IsNewObj(res)) delete ptr;
}
result = (cv::Vec< uint8_t,4 > *)new_cv_Vec_Sl_uint8_t_Sc_4_Sg___SWIG_4(arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__VecT_unsigned_char_4_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Vec_uint8_t_4(PyObject *self, PyObject *args) {
Py_ssize_t argc;
PyObject *argv[4] = {
0
};
Py_ssize_t ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = args ? PyObject_Length(args) : 0;
for (ii = 0; (ii < 3) && (ii < argc); 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_unsigned_char, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Vec_uint8_t_4__SWIG_0(self, args);
}
}
if (argc == 1) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__VecT_unsigned_char_4_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Vec_uint8_t_4__SWIG_1(self, args);
}
}
if (argc == 1) {
int _v;
int res = swig::asptr(argv[0], (std::vector< unsigned char,std::allocator< unsigned char > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Vec_uint8_t_4__SWIG_4(self, args);
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_unsigned_char_4_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_unsigned_char_4_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_SubOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Vec_uint8_t_4__SWIG_3(self, args);
}
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_unsigned_char_4_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_unsigned_char_4_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_AddOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Vec_uint8_t_4__SWIG_2(self, args);
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new__Vec_uint8_t_4'.\n"
" Possible C/C++ prototypes are:\n"
" cv::Vec< uint8_t,4 >::Vec(unsigned char const *)\n"
" cv::Vec< uint8_t,4 >::Vec(cv::Vec< unsigned char,4 > const &)\n"
" cv::Vec< uint8_t,4 >::Vec(cv::Matx< unsigned char,4,1 > const &,cv::Matx< unsigned char,4,1 > const &,cv::Matx_AddOp)\n"
" cv::Vec< uint8_t,4 >::Vec(cv::Matx< unsigned char,4,1 > const &,cv::Matx< unsigned char,4,1 > const &,cv::Matx_SubOp)\n"
" cv::Vec< uint8_t,4 >::Vec(std::vector< cv::Vec< unsigned char,4 >::value_type,std::allocator< cv::Vec< uint8_t,4 >::value_type > >)\n");
return 0;
}
SWIGINTERN PyObject *_wrap__Vec_uint8_t_4___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Vec< uint8_t,4 > *arg1 = (cv::Vec< uint8_t,4 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
std::string result;
if (!PyArg_ParseTuple(args,(char *)"O:_Vec_uint8_t_4___str__",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__VecT_unsigned_char_4_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Vec_uint8_t_4___str__" "', argument " "1"" of type '" "cv::Vec< uint8_t,4 > *""'");
}
arg1 = reinterpret_cast< cv::Vec< uint8_t,4 > * >(argp1);
result = cv_Vec_Sl_uint8_t_Sc_4_Sg____str__(arg1);
resultobj = SWIG_From_std_string(static_cast< std::string >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete__Vec_uint8_t_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Vec< uint8_t,4 > *arg1 = (cv::Vec< uint8_t,4 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete__Vec_uint8_t_4",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__VecT_unsigned_char_4_t, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__Vec_uint8_t_4" "', argument " "1"" of type '" "cv::Vec< uint8_t,4 > *""'");
}
arg1 = reinterpret_cast< cv::Vec< uint8_t,4 > * >(argp1);
delete arg1;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_Vec_uint8_t_4_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_cv__VecT_unsigned_char_4_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_new__DataType_Vec_uint8_t_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::DataType< cv::Vec< uint8_t,4 > > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new__DataType_Vec_uint8_t_4")) SWIG_fail;
result = (cv::DataType< cv::Vec< uint8_t,4 > > *)new cv::DataType< cv::Vec< uint8_t,4 > >();
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__DataTypeT_cv__VecT_uint8_t_4_t_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete__DataType_Vec_uint8_t_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::DataType< cv::Vec< uint8_t,4 > > *arg1 = (cv::DataType< cv::Vec< uint8_t,4 > > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete__DataType_Vec_uint8_t_4",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__DataTypeT_cv__VecT_uint8_t_4_t_t, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__DataType_Vec_uint8_t_4" "', argument " "1"" of type '" "cv::DataType< cv::Vec< uint8_t,4 > > *""'");
}
arg1 = reinterpret_cast< cv::DataType< cv::Vec< uint8_t,4 > > * >(argp1);
delete arg1;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_DataType_Vec_uint8_t_4_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_cv__DataTypeT_cv__VecT_uint8_t_4_t_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_new__cv_numpy_sizeof_short(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::_SizeOf< short > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new__cv_numpy_sizeof_short")) SWIG_fail;
result = (cv::_SizeOf< short > *)new cv::_SizeOf< short >();
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv___SizeOfT_short_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete__cv_numpy_sizeof_short(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::_SizeOf< short > *arg1 = (cv::_SizeOf< short > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete__cv_numpy_sizeof_short",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv___SizeOfT_short_t, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__cv_numpy_sizeof_short" "', argument " "1"" of type '" "cv::_SizeOf< short > *""'");
}
arg1 = reinterpret_cast< cv::_SizeOf< short > * >(argp1);
delete arg1;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_cv_numpy_sizeof_short_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_cv___SizeOfT_short_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap__shortArray_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< short > *arg1 = (std::vector< short > *) 0 ;
PyObject **arg2 = (PyObject **) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
swig::SwigPyIterator *result = 0 ;
arg2 = &obj0;
if (!PyArg_ParseTuple(args,(char *)"O:_shortArray_iterator",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_short_std__allocatorT_short_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_shortArray_iterator" "', argument " "1"" of type '" "std::vector< short > *""'");
}
arg1 = reinterpret_cast< std::vector< short > * >(argp1);
result = (swig::SwigPyIterator *)std_vector_Sl_short_Sg__iterator(arg1,arg2);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__shortArray___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< short > *arg1 = (std::vector< short > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
bool result;
if (!PyArg_ParseTuple(args,(char *)"O:_shortArray___nonzero__",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_short_std__allocatorT_short_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_shortArray___nonzero__" "', argument " "1"" of type '" "std::vector< short > const *""'");
}
arg1 = reinterpret_cast< std::vector< short > * >(argp1);
result = (bool)std_vector_Sl_short_Sg____nonzero__((std::vector< short > const *)arg1);
resultobj = SWIG_From_bool(static_cast< bool >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__shortArray___bool__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< short > *arg1 = (std::vector< short > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
bool result;
if (!PyArg_ParseTuple(args,(char *)"O:_shortArray___bool__",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_short_std__allocatorT_short_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_shortArray___bool__" "', argument " "1"" of type '" "std::vector< short > const *""'");
}
arg1 = reinterpret_cast< std::vector< short > * >(argp1);
result = (bool)std_vector_Sl_short_Sg____bool__((std::vector< short > const *)arg1);
resultobj = SWIG_From_bool(static_cast< bool >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__shortArray___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< short > *arg1 = (std::vector< short > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
std::vector< short >::size_type result;
if (!PyArg_ParseTuple(args,(char *)"O:_shortArray___len__",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_short_std__allocatorT_short_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_shortArray___len__" "', argument " "1"" of type '" "std::vector< short > const *""'");
}
arg1 = reinterpret_cast< std::vector< short > * >(argp1);
result = std_vector_Sl_short_Sg____len__((std::vector< short > const *)arg1);
resultobj = SWIG_From_size_t(static_cast< size_t >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__shortArray___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< short > *arg1 = (std::vector< short > *) 0 ;
std::vector< short >::difference_type arg2 ;
std::vector< short >::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< short,std::allocator< short > > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:_shortArray___getslice__",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_short_std__allocatorT_short_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_shortArray___getslice__" "', argument " "1"" of type '" "std::vector< short > *""'");
}
arg1 = reinterpret_cast< std::vector< short > * >(argp1);
ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_shortArray___getslice__" "', argument " "2"" of type '" "std::vector< short >::difference_type""'");
}
arg2 = static_cast< std::vector< short >::difference_type >(val2);
ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "_shortArray___getslice__" "', argument " "3"" of type '" "std::vector< short >::difference_type""'");
}
arg3 = static_cast< std::vector< short >::difference_type >(val3);
try {
result = (std::vector< short,std::allocator< short > > *)std_vector_Sl_short_Sg____getslice__(arg1,arg2,arg3);
}
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_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_short_std__allocatorT_short_t_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__shortArray___setslice____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< short > *arg1 = (std::vector< short > *) 0 ;
std::vector< short >::difference_type arg2 ;
std::vector< short >::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:_shortArray___setslice__",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_short_std__allocatorT_short_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_shortArray___setslice__" "', argument " "1"" of type '" "std::vector< short > *""'");
}
arg1 = reinterpret_cast< std::vector< short > * >(argp1);
ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_shortArray___setslice__" "', argument " "2"" of type '" "std::vector< short >::difference_type""'");
}
arg2 = static_cast< std::vector< short >::difference_type >(val2);
ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "_shortArray___setslice__" "', argument " "3"" of type '" "std::vector< short >::difference_type""'");
}
arg3 = static_cast< std::vector< short >::difference_type >(val3);
try {
std_vector_Sl_short_Sg____setslice____SWIG_0(arg1,arg2,arg3);
}
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();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__shortArray___setslice____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< short > *arg1 = (std::vector< short > *) 0 ;
std::vector< short >::difference_type arg2 ;
std::vector< short >::difference_type arg3 ;
std::vector< short,std::allocator< short > > *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:_shortArray___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_short_std__allocatorT_short_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_shortArray___setslice__" "', argument " "1"" of type '" "std::vector< short > *""'");
}
arg1 = reinterpret_cast< std::vector< short > * >(argp1);
ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_shortArray___setslice__" "', argument " "2"" of type '" "std::vector< short >::difference_type""'");
}
arg2 = static_cast< std::vector< short >::difference_type >(val2);
ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "_shortArray___setslice__" "', argument " "3"" of type '" "std::vector< short >::difference_type""'");
}
arg3 = static_cast< std::vector< short >::difference_type >(val3);
{
std::vector< short,std::allocator< short > > *ptr = (std::vector< short,std::allocator< short > > *)0;
res4 = swig::asptr(obj3, &ptr);
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "_shortArray___setslice__" "', argument " "4"" of type '" "std::vector< short,std::allocator< short > > const &""'");
}
if (!ptr) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_shortArray___setslice__" "', argument " "4"" of type '" "std::vector< short,std::allocator< short > > const &""'");
}
arg4 = ptr;
}
try {
std_vector_Sl_short_Sg____setslice____SWIG_1(arg1,arg2,arg3,(std::vector< short,std::allocator< short > > 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__shortArray___setslice__(PyObject *self, PyObject *args) {
Py_ssize_t argc;
PyObject *argv[5] = {
0
};
Py_ssize_t ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = args ? PyObject_Length(args) : 0;
for (ii = 0; (ii < 4) && (ii < argc); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 3) {
int _v;
int res = swig::asptr(argv[0], (std::vector< short,std::allocator< short > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap__shortArray___setslice____SWIG_0(self, args);
}
}
}
}
if (argc == 4) {
int _v;
int res = swig::asptr(argv[0], (std::vector< short,std::allocator< short > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
int res = swig::asptr(argv[3], (std::vector< short,std::allocator< short > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
return _wrap__shortArray___setslice____SWIG_1(self, args);
}
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function '_shortArray___setslice__'.\n"
" Possible C/C++ prototypes are:\n"
" std::vector< short >::__setslice__(std::vector< short >::difference_type,std::vector< short >::difference_type)\n"
" std::vector< short >::__setslice__(std::vector< short >::difference_type,std::vector< short >::difference_type,std::vector< short,std::allocator< short > > const &)\n");
return 0;
}
SWIGINTERN PyObject *_wrap__shortArray___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< short > *arg1 = (std::vector< short > *) 0 ;
std::vector< short >::difference_type arg2 ;
std::vector< short >::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:_shortArray___delslice__",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_short_std__allocatorT_short_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_shortArray___delslice__" "', argument " "1"" of type '" "std::vector< short > *""'");
}
arg1 = reinterpret_cast< std::vector< short > * >(argp1);
ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_shortArray___delslice__" "', argument " "2"" of type '" "std::vector< short >::difference_type""'");
}
arg2 = static_cast< std::vector< short >::difference_type >(val2);
ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "_shortArray___delslice__" "', argument " "3"" of type '" "std::vector< short >::difference_type""'");
}
arg3 = static_cast< std::vector< short >::difference_type >(val3);
try {
std_vector_Sl_short_Sg____delslice__(arg1,arg2,arg3);
}
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();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__shortArray___delitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< short > *arg1 = (std::vector< short > *) 0 ;
std::vector< short >::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:_shortArray___delitem__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_short_std__allocatorT_short_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_shortArray___delitem__" "', argument " "1"" of type '" "std::vector< short > *""'");
}
arg1 = reinterpret_cast< std::vector< short > * >(argp1);
ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_shortArray___delitem__" "', argument " "2"" of type '" "std::vector< short >::difference_type""'");
}
arg2 = static_cast< std::vector< short >::difference_type >(val2);
try {
std_vector_Sl_short_Sg____delitem____SWIG_0(arg1,arg2);
}
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();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__shortArray___getitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< short > *arg1 = (std::vector< short > *) 0 ;
PySliceObject *arg2 = (PySliceObject *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
std::vector< short,std::allocator< short > > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:_shortArray___getitem__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_short_std__allocatorT_short_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_shortArray___getitem__" "', argument " "1"" of type '" "std::vector< short > *""'");
}
arg1 = reinterpret_cast< std::vector< short > * >(argp1);
{
if (!PySlice_Check(obj1)) {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "_shortArray___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
arg2 = (PySliceObject *) obj1;
}
try {
result = (std::vector< short,std::allocator< short > > *)std_vector_Sl_short_Sg____getitem____SWIG_0(arg1,arg2);
}
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_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_short_std__allocatorT_short_t_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__shortArray___setitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< short > *arg1 = (std::vector< short > *) 0 ;
PySliceObject *arg2 = (PySliceObject *) 0 ;
std::vector< short,std::allocator< short > > *arg3 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res3 = SWIG_OLDOBJ ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:_shortArray___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_short_std__allocatorT_short_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_shortArray___setitem__" "', argument " "1"" of type '" "std::vector< short > *""'");
}
arg1 = reinterpret_cast< std::vector< short > * >(argp1);
{
if (!PySlice_Check(obj1)) {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "_shortArray___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
arg2 = (PySliceObject *) obj1;
}
{
std::vector< short,std::allocator< short > > *ptr = (std::vector< short,std::allocator< short > > *)0;
res3 = swig::asptr(obj2, &ptr);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "_shortArray___setitem__" "', argument " "3"" of type '" "std::vector< short,std::allocator< short > > const &""'");
}
if (!ptr) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_shortArray___setitem__" "', argument " "3"" of type '" "std::vector< short,std::allocator< short > > const &""'");
}
arg3 = ptr;
}
try {
std_vector_Sl_short_Sg____setitem____SWIG_0(arg1,arg2,(std::vector< short,std::allocator< short > > const &)*arg3);
}
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(res3)) delete arg3;
return resultobj;
fail:
if (SWIG_IsNewObj(res3)) delete arg3;
return NULL;
}
SWIGINTERN PyObject *_wrap__shortArray___setitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< short > *arg1 = (std::vector< short > *) 0 ;
PySliceObject *arg2 = (PySliceObject *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:_shortArray___setitem__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_short_std__allocatorT_short_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_shortArray___setitem__" "', argument " "1"" of type '" "std::vector< short > *""'");
}
arg1 = reinterpret_cast< std::vector< short > * >(argp1);
{
if (!PySlice_Check(obj1)) {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "_shortArray___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
arg2 = (PySliceObject *) obj1;
}
try {
std_vector_Sl_short_Sg____setitem____SWIG_1(arg1,arg2);
}
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();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__shortArray___delitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< short > *arg1 = (std::vector< short > *) 0 ;
PySliceObject *arg2 = (PySliceObject *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:_shortArray___delitem__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_short_std__allocatorT_short_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_shortArray___delitem__" "', argument " "1"" of type '" "std::vector< short > *""'");
}
arg1 = reinterpret_cast< std::vector< short > * >(argp1);
{
if (!PySlice_Check(obj1)) {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "_shortArray___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
arg2 = (PySliceObject *) obj1;
}
try {
std_vector_Sl_short_Sg____delitem____SWIG_1(arg1,arg2);
}
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();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__shortArray___delitem__(PyObject *self, PyObject *args) {
Py_ssize_t argc;
PyObject *argv[3] = {
0
};
Py_ssize_t ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = args ? PyObject_Length(args) : 0;
for (ii = 0; (ii < 2) && (ii < argc); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 2) {
int _v;
int res = swig::asptr(argv[0], (std::vector< short,std::allocator< short > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
{
_v = PySlice_Check(argv[1]);
}
if (_v) {
return _wrap__shortArray___delitem____SWIG_1(self, args);
}
}
}
if (argc == 2) {
int _v;
int res = swig::asptr(argv[0], (std::vector< short,std::allocator< short > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap__shortArray___delitem____SWIG_0(self, args);
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function '_shortArray___delitem__'.\n"
" Possible C/C++ prototypes are:\n"
" std::vector< short >::__delitem__(std::vector< short >::difference_type)\n"
" std::vector< short >::__delitem__(PySliceObject *)\n");
return 0;
}
SWIGINTERN PyObject *_wrap__shortArray___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< short > *arg1 = (std::vector< short > *) 0 ;
std::vector< short >::difference_type arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
ptrdiff_t val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
std::vector< short >::value_type *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:_shortArray___getitem__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_short_std__allocatorT_short_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_shortArray___getitem__" "', argument " "1"" of type '" "std::vector< short > const *""'");
}
arg1 = reinterpret_cast< std::vector< short > * >(argp1);
ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_shortArray___getitem__" "', argument " "2"" of type '" "std::vector< short >::difference_type""'");
}
arg2 = static_cast< std::vector< short >::difference_type >(val2);
try {
result = (std::vector< short >::value_type *) &std_vector_Sl_short_Sg____getitem____SWIG_1((std::vector< short > const *)arg1,arg2);
}
catch(std::out_of_range &_e) {
SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
}
resultobj = SWIG_From_short(static_cast< short >(*result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__shortArray___getitem__(PyObject *self, PyObject *args) {
Py_ssize_t argc;
PyObject *argv[3] = {
0
};
Py_ssize_t ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = args ? PyObject_Length(args) : 0;
for (ii = 0; (ii < 2) && (ii < argc); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 2) {
int _v;
int res = swig::asptr(argv[0], (std::vector< short,std::allocator< short > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
{
_v = PySlice_Check(argv[1]);
}
if (_v) {
return _wrap__shortArray___getitem____SWIG_0(self, args);
}
}
}
if (argc == 2) {
int _v;
int res = swig::asptr(argv[0], (std::vector< short,std::allocator< short > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap__shortArray___getitem____SWIG_1(self, args);
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function '_shortArray___getitem__'.\n"
" Possible C/C++ prototypes are:\n"
" std::vector< short >::__getitem__(PySliceObject *)\n"
" std::vector< short >::__getitem__(std::vector< short >::difference_type) const\n");
return 0;
}
SWIGINTERN PyObject *_wrap__shortArray___setitem____SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< short > *arg1 = (std::vector< short > *) 0 ;
std::vector< short >::difference_type arg2 ;
std::vector< short >::value_type *arg3 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
ptrdiff_t val2 ;
int ecode2 = 0 ;
std::vector< short >::value_type temp3 ;
short val3 ;
int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:_shortArray___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_short_std__allocatorT_short_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_shortArray___setitem__" "', argument " "1"" of type '" "std::vector< short > *""'");
}
arg1 = reinterpret_cast< std::vector< short > * >(argp1);
ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_shortArray___setitem__" "', argument " "2"" of type '" "std::vector< short >::difference_type""'");
}
arg2 = static_cast< std::vector< short >::difference_type >(val2);
ecode3 = SWIG_AsVal_short(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "_shortArray___setitem__" "', argument " "3"" of type '" "std::vector< short >::value_type""'");
}
temp3 = static_cast< std::vector< short >::value_type >(val3);
arg3 = &temp3;
try {
std_vector_Sl_short_Sg____setitem____SWIG_2(arg1,arg2,(short 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__shortArray___setitem__(PyObject *self, PyObject *args) {
Py_ssize_t argc;
PyObject *argv[4] = {
0
};
Py_ssize_t ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = args ? PyObject_Length(args) : 0;
for (ii = 0; (ii < 3) && (ii < argc); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 2) {
int _v;
int res = swig::asptr(argv[0], (std::vector< short,std::allocator< short > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
{
_v = PySlice_Check(argv[1]);
}
if (_v) {
return _wrap__shortArray___setitem____SWIG_1(self, args);
}
}
}
if (argc == 3) {
int _v;
int res = swig::asptr(argv[0], (std::vector< short,std::allocator< short > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
{
_v = PySlice_Check(argv[1]);
}
if (_v) {
int res = swig::asptr(argv[2], (std::vector< short,std::allocator< short > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
return _wrap__shortArray___setitem____SWIG_0(self, args);
}
}
}
}
if (argc == 3) {
int _v;
int res = swig::asptr(argv[0], (std::vector< short,std::allocator< short > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_short(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap__shortArray___setitem____SWIG_2(self, args);
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function '_shortArray___setitem__'.\n"
" Possible C/C++ prototypes are:\n"
" std::vector< short >::__setitem__(PySliceObject *,std::vector< short,std::allocator< short > > const &)\n"
" std::vector< short >::__setitem__(PySliceObject *)\n"
" std::vector< short >::__setitem__(std::vector< short >::difference_type,std::vector< short >::value_type const &)\n");
return 0;
}
SWIGINTERN PyObject *_wrap__shortArray_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< short > *arg1 = (std::vector< short > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
std::vector< short >::value_type result;
if (!PyArg_ParseTuple(args,(char *)"O:_shortArray_pop",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_short_std__allocatorT_short_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_shortArray_pop" "', argument " "1"" of type '" "std::vector< short > *""'");
}
arg1 = reinterpret_cast< std::vector< short > * >(argp1);
try {
result = (std::vector< short >::value_type)std_vector_Sl_short_Sg__pop(arg1);
}
catch(std::out_of_range &_e) {
SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
}
resultobj = SWIG_From_short(static_cast< short >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__shortArray_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< short > *arg1 = (std::vector< short > *) 0 ;
std::vector< short >::value_type *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
std::vector< short >::value_type temp2 ;
short val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:_shortArray_append",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_short_std__allocatorT_short_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_shortArray_append" "', argument " "1"" of type '" "std::vector< short > *""'");
}
arg1 = reinterpret_cast< std::vector< short > * >(argp1);
ecode2 = SWIG_AsVal_short(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_shortArray_append" "', argument " "2"" of type '" "std::vector< short >::value_type""'");
}
temp2 = static_cast< std::vector< short >::value_type >(val2);
arg2 = &temp2;
std_vector_Sl_short_Sg__append(arg1,(short const &)*arg2);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__shortArray__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< short > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new__shortArray")) SWIG_fail;
result = (std::vector< short > *)new std::vector< short >();
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_short_std__allocatorT_short_t_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__shortArray__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< short > *arg1 = 0 ;
int res1 = SWIG_OLDOBJ ;
PyObject * obj0 = 0 ;
std::vector< short > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__shortArray",&obj0)) SWIG_fail;
{
std::vector< short,std::allocator< short > > *ptr = (std::vector< short,std::allocator< short > > *)0;
res1 = swig::asptr(obj0, &ptr);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__shortArray" "', argument " "1"" of type '" "std::vector< short > const &""'");
}
if (!ptr) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__shortArray" "', argument " "1"" of type '" "std::vector< short > const &""'");
}
arg1 = ptr;
}
result = (std::vector< short > *)new std::vector< short >((std::vector< short > const &)*arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_short_std__allocatorT_short_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__shortArray_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< short > *arg1 = (std::vector< short > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
bool result;
if (!PyArg_ParseTuple(args,(char *)"O:_shortArray_empty",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_short_std__allocatorT_short_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_shortArray_empty" "', argument " "1"" of type '" "std::vector< short > const *""'");
}
arg1 = reinterpret_cast< std::vector< short > * >(argp1);
result = (bool)((std::vector< short > const *)arg1)->empty();
resultobj = SWIG_From_bool(static_cast< bool >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__shortArray_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< short > *arg1 = (std::vector< short > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
std::vector< short >::size_type result;
if (!PyArg_ParseTuple(args,(char *)"O:_shortArray_size",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_short_std__allocatorT_short_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_shortArray_size" "', argument " "1"" of type '" "std::vector< short > const *""'");
}
arg1 = reinterpret_cast< std::vector< short > * >(argp1);
result = ((std::vector< short > const *)arg1)->size();
resultobj = SWIG_From_size_t(static_cast< size_t >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__shortArray_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< short > *arg1 = (std::vector< short > *) 0 ;
std::vector< short > *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:_shortArray_swap",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_short_std__allocatorT_short_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_shortArray_swap" "', argument " "1"" of type '" "std::vector< short > *""'");
}
arg1 = reinterpret_cast< std::vector< short > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_short_std__allocatorT_short_t_t, 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_shortArray_swap" "', argument " "2"" of type '" "std::vector< short > &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_shortArray_swap" "', argument " "2"" of type '" "std::vector< short > &""'");
}
arg2 = reinterpret_cast< std::vector< short > * >(argp2);
(arg1)->swap(*arg2);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__shortArray_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< short > *arg1 = (std::vector< short > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
std::vector< short >::iterator result;
if (!PyArg_ParseTuple(args,(char *)"O:_shortArray_begin",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_short_std__allocatorT_short_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_shortArray_begin" "', argument " "1"" of type '" "std::vector< short > *""'");
}
arg1 = reinterpret_cast< std::vector< short > * >(argp1);
result = (arg1)->begin();
resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< short >::iterator & >(result)),
swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__shortArray_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< short > *arg1 = (std::vector< short > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
std::vector< short >::iterator result;
if (!PyArg_ParseTuple(args,(char *)"O:_shortArray_end",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_short_std__allocatorT_short_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_shortArray_end" "', argument " "1"" of type '" "std::vector< short > *""'");
}
arg1 = reinterpret_cast< std::vector< short > * >(argp1);
result = (arg1)->end();
resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< short >::iterator & >(result)),
swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__shortArray_rbegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< short > *arg1 = (std::vector< short > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
std::vector< short >::reverse_iterator result;
if (!PyArg_ParseTuple(args,(char *)"O:_shortArray_rbegin",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_short_std__allocatorT_short_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_shortArray_rbegin" "', argument " "1"" of type '" "std::vector< short > *""'");
}
arg1 = reinterpret_cast< std::vector< short > * >(argp1);
result = (arg1)->rbegin();
resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< short >::reverse_iterator & >(result)),
swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__shortArray_rend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< short > *arg1 = (std::vector< short > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
std::vector< short >::reverse_iterator result;
if (!PyArg_ParseTuple(args,(char *)"O:_shortArray_rend",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_short_std__allocatorT_short_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_shortArray_rend" "', argument " "1"" of type '" "std::vector< short > *""'");
}
arg1 = reinterpret_cast< std::vector< short > * >(argp1);
result = (arg1)->rend();
resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< short >::reverse_iterator & >(result)),
swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__shortArray_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< short > *arg1 = (std::vector< short > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:_shortArray_clear",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_short_std__allocatorT_short_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_shortArray_clear" "', argument " "1"" of type '" "std::vector< short > *""'");
}
arg1 = reinterpret_cast< std::vector< short > * >(argp1);
(arg1)->clear();
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__shortArray_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< short > *arg1 = (std::vector< short > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
SwigValueWrapper< std::allocator< short > > result;
if (!PyArg_ParseTuple(args,(char *)"O:_shortArray_get_allocator",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_short_std__allocatorT_short_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_shortArray_get_allocator" "', argument " "1"" of type '" "std::vector< short > const *""'");
}
arg1 = reinterpret_cast< std::vector< short > * >(argp1);
result = ((std::vector< short > const *)arg1)->get_allocator();
resultobj = SWIG_NewPointerObj((new std::vector< short >::allocator_type(static_cast< const std::vector< short >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_short_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__shortArray__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< short >::size_type arg1 ;
size_t val1 ;
int ecode1 = 0 ;
PyObject * obj0 = 0 ;
std::vector< short > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__shortArray",&obj0)) SWIG_fail;
ecode1 = SWIG_AsVal_size_t(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new__shortArray" "', argument " "1"" of type '" "std::vector< short >::size_type""'");
}
arg1 = static_cast< std::vector< short >::size_type >(val1);
result = (std::vector< short > *)new std::vector< short >(arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_short_std__allocatorT_short_t_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__shortArray_pop_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< short > *arg1 = (std::vector< short > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:_shortArray_pop_back",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_short_std__allocatorT_short_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_shortArray_pop_back" "', argument " "1"" of type '" "std::vector< short > *""'");
}
arg1 = reinterpret_cast< std::vector< short > * >(argp1);
(arg1)->pop_back();
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__shortArray_resize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< short > *arg1 = (std::vector< short > *) 0 ;
std::vector< short >::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:_shortArray_resize",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_short_std__allocatorT_short_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_shortArray_resize" "', argument " "1"" of type '" "std::vector< short > *""'");
}
arg1 = reinterpret_cast< std::vector< short > * >(argp1);
ecode2 = SWIG_AsVal_size_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_shortArray_resize" "', argument " "2"" of type '" "std::vector< short >::size_type""'");
}
arg2 = static_cast< std::vector< short >::size_type >(val2);
(arg1)->resize(arg2);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__shortArray_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< short > *arg1 = (std::vector< short > *) 0 ;
std::vector< short >::iterator arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
swig::SwigPyIterator *iter2 = 0 ;
int res2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
std::vector< short >::iterator result;
if (!PyArg_ParseTuple(args,(char *)"OO:_shortArray_erase",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_short_std__allocatorT_short_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_shortArray_erase" "', argument " "1"" of type '" "std::vector< short > *""'");
}
arg1 = reinterpret_cast< std::vector< short > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
if (!SWIG_IsOK(res2) || !iter2) {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "_shortArray_erase" "', argument " "2"" of type '" "std::vector< short >::iterator""'");
} else {
swig::SwigPyIterator_T<std::vector< short >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< short >::iterator > *>(iter2);
if (iter_t) {
arg2 = iter_t->get_current();
} else {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "_shortArray_erase" "', argument " "2"" of type '" "std::vector< short >::iterator""'");
}
}
result = std_vector_Sl_short_Sg__erase__SWIG_0(arg1,arg2);
resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< short >::iterator & >(result)),
swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__shortArray_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< short > *arg1 = (std::vector< short > *) 0 ;
std::vector< short >::iterator arg2 ;
std::vector< short >::iterator arg3 ;
void *argp1 = 0 ;
int res1 = 0 ;
swig::SwigPyIterator *iter2 = 0 ;
int res2 ;
swig::SwigPyIterator *iter3 = 0 ;
int res3 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
std::vector< short >::iterator result;
if (!PyArg_ParseTuple(args,(char *)"OOO:_shortArray_erase",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_short_std__allocatorT_short_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_shortArray_erase" "', argument " "1"" of type '" "std::vector< short > *""'");
}
arg1 = reinterpret_cast< std::vector< short > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
if (!SWIG_IsOK(res2) || !iter2) {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "_shortArray_erase" "', argument " "2"" of type '" "std::vector< short >::iterator""'");
} else {
swig::SwigPyIterator_T<std::vector< short >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< short >::iterator > *>(iter2);
if (iter_t) {
arg2 = iter_t->get_current();
} else {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "_shortArray_erase" "', argument " "2"" of type '" "std::vector< short >::iterator""'");
}
}
res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
if (!SWIG_IsOK(res3) || !iter3) {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "_shortArray_erase" "', argument " "3"" of type '" "std::vector< short >::iterator""'");
} else {
swig::SwigPyIterator_T<std::vector< short >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< short >::iterator > *>(iter3);
if (iter_t) {
arg3 = iter_t->get_current();
} else {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "_shortArray_erase" "', argument " "3"" of type '" "std::vector< short >::iterator""'");
}
}
result = std_vector_Sl_short_Sg__erase__SWIG_1(arg1,arg2,arg3);
resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< short >::iterator & >(result)),
swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__shortArray_erase(PyObject *self, PyObject *args) {
Py_ssize_t argc;
PyObject *argv[4] = {
0
};
Py_ssize_t ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = args ? PyObject_Length(args) : 0;
for (ii = 0; (ii < 3) && (ii < argc); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 2) {
int _v;
int res = swig::asptr(argv[0], (std::vector< short,std::allocator< short > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
swig::SwigPyIterator *iter = 0;
int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
_v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< short >::iterator > *>(iter) != 0));
if (_v) {
return _wrap__shortArray_erase__SWIG_0(self, args);
}
}
}
if (argc == 3) {
int _v;
int res = swig::asptr(argv[0], (std::vector< short,std::allocator< short > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
swig::SwigPyIterator *iter = 0;
int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
_v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< short >::iterator > *>(iter) != 0));
if (_v) {
swig::SwigPyIterator *iter = 0;
int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
_v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< short >::iterator > *>(iter) != 0));
if (_v) {
return _wrap__shortArray_erase__SWIG_1(self, args);
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function '_shortArray_erase'.\n"
" Possible C/C++ prototypes are:\n"
" std::vector< short >::erase(std::vector< short >::iterator)\n"
" std::vector< short >::erase(std::vector< short >::iterator,std::vector< short >::iterator)\n");
return 0;
}
SWIGINTERN PyObject *_wrap_new__shortArray__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< short >::size_type arg1 ;
std::vector< short >::value_type *arg2 = 0 ;
size_t val1 ;
int ecode1 = 0 ;
std::vector< short >::value_type temp2 ;
short val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
std::vector< short > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:new__shortArray",&obj0,&obj1)) SWIG_fail;
ecode1 = SWIG_AsVal_size_t(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new__shortArray" "', argument " "1"" of type '" "std::vector< short >::size_type""'");
}
arg1 = static_cast< std::vector< short >::size_type >(val1);
ecode2 = SWIG_AsVal_short(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new__shortArray" "', argument " "2"" of type '" "std::vector< short >::value_type""'");
}
temp2 = static_cast< std::vector< short >::value_type >(val2);
arg2 = &temp2;
result = (std::vector< short > *)new std::vector< short >(arg1,(std::vector< short >::value_type const &)*arg2);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_short_std__allocatorT_short_t_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__shortArray(PyObject *self, PyObject *args) {
Py_ssize_t argc;
PyObject *argv[3] = {
0
};
Py_ssize_t ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = args ? PyObject_Length(args) : 0;
for (ii = 0; (ii < 2) && (ii < argc); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 0) {
return _wrap_new__shortArray__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__shortArray__SWIG_2(self, args);
}
}
if (argc == 1) {
int _v;
int res = swig::asptr(argv[0], (std::vector< short,std::allocator< short > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__shortArray__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_short(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_new__shortArray__SWIG_3(self, args);
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new__shortArray'.\n"
" Possible C/C++ prototypes are:\n"
" std::vector< short >::vector()\n"
" std::vector< short >::vector(std::vector< short > const &)\n"
" std::vector< short >::vector(std::vector< short >::size_type)\n"
" std::vector< short >::vector(std::vector< short >::size_type,std::vector< short >::value_type const &)\n");
return 0;
}
SWIGINTERN PyObject *_wrap__shortArray_push_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< short > *arg1 = (std::vector< short > *) 0 ;
std::vector< short >::value_type *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
std::vector< short >::value_type temp2 ;
short val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:_shortArray_push_back",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_short_std__allocatorT_short_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_shortArray_push_back" "', argument " "1"" of type '" "std::vector< short > *""'");
}
arg1 = reinterpret_cast< std::vector< short > * >(argp1);
ecode2 = SWIG_AsVal_short(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_shortArray_push_back" "', argument " "2"" of type '" "std::vector< short >::value_type""'");
}
temp2 = static_cast< std::vector< short >::value_type >(val2);
arg2 = &temp2;
(arg1)->push_back((std::vector< short >::value_type const &)*arg2);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__shortArray_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< short > *arg1 = (std::vector< short > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
std::vector< short >::value_type *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:_shortArray_front",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_short_std__allocatorT_short_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_shortArray_front" "', argument " "1"" of type '" "std::vector< short > const *""'");
}
arg1 = reinterpret_cast< std::vector< short > * >(argp1);
result = (std::vector< short >::value_type *) &((std::vector< short > const *)arg1)->front();
resultobj = SWIG_From_short(static_cast< short >(*result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__shortArray_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< short > *arg1 = (std::vector< short > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
std::vector< short >::value_type *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:_shortArray_back",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_short_std__allocatorT_short_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_shortArray_back" "', argument " "1"" of type '" "std::vector< short > const *""'");
}
arg1 = reinterpret_cast< std::vector< short > * >(argp1);
result = (std::vector< short >::value_type *) &((std::vector< short > const *)arg1)->back();
resultobj = SWIG_From_short(static_cast< short >(*result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__shortArray_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< short > *arg1 = (std::vector< short > *) 0 ;
std::vector< short >::size_type arg2 ;
std::vector< short >::value_type *arg3 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
size_t val2 ;
int ecode2 = 0 ;
std::vector< short >::value_type temp3 ;
short val3 ;
int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:_shortArray_assign",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_short_std__allocatorT_short_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_shortArray_assign" "', argument " "1"" of type '" "std::vector< short > *""'");
}
arg1 = reinterpret_cast< std::vector< short > * >(argp1);
ecode2 = SWIG_AsVal_size_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_shortArray_assign" "', argument " "2"" of type '" "std::vector< short >::size_type""'");
}
arg2 = static_cast< std::vector< short >::size_type >(val2);
ecode3 = SWIG_AsVal_short(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "_shortArray_assign" "', argument " "3"" of type '" "std::vector< short >::value_type""'");
}
temp3 = static_cast< std::vector< short >::value_type >(val3);
arg3 = &temp3;
(arg1)->assign(arg2,(std::vector< short >::value_type const &)*arg3);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__shortArray_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< short > *arg1 = (std::vector< short > *) 0 ;
std::vector< short >::size_type arg2 ;
std::vector< short >::value_type *arg3 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
size_t val2 ;
int ecode2 = 0 ;
std::vector< short >::value_type temp3 ;
short val3 ;
int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:_shortArray_resize",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_short_std__allocatorT_short_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_shortArray_resize" "', argument " "1"" of type '" "std::vector< short > *""'");
}
arg1 = reinterpret_cast< std::vector< short > * >(argp1);
ecode2 = SWIG_AsVal_size_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_shortArray_resize" "', argument " "2"" of type '" "std::vector< short >::size_type""'");
}
arg2 = static_cast< std::vector< short >::size_type >(val2);
ecode3 = SWIG_AsVal_short(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "_shortArray_resize" "', argument " "3"" of type '" "std::vector< short >::value_type""'");
}
temp3 = static_cast< std::vector< short >::value_type >(val3);
arg3 = &temp3;
(arg1)->resize(arg2,(std::vector< short >::value_type const &)*arg3);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__shortArray_resize(PyObject *self, PyObject *args) {
Py_ssize_t argc;
PyObject *argv[4] = {
0
};
Py_ssize_t ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = args ? PyObject_Length(args) : 0;
for (ii = 0; (ii < 3) && (ii < argc); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 2) {
int _v;
int res = swig::asptr(argv[0], (std::vector< short,std::allocator< short > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_size_t(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap__shortArray_resize__SWIG_0(self, args);
}
}
}
if (argc == 3) {
int _v;
int res = swig::asptr(argv[0], (std::vector< short,std::allocator< short > >**)(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_short(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap__shortArray_resize__SWIG_1(self, args);
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function '_shortArray_resize'.\n"
" Possible C/C++ prototypes are:\n"
" std::vector< short >::resize(std::vector< short >::size_type)\n"
" std::vector< short >::resize(std::vector< short >::size_type,std::vector< short >::value_type const &)\n");
return 0;
}
SWIGINTERN PyObject *_wrap__shortArray_insert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< short > *arg1 = (std::vector< short > *) 0 ;
std::vector< short >::iterator arg2 ;
std::vector< short >::value_type *arg3 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
swig::SwigPyIterator *iter2 = 0 ;
int res2 ;
std::vector< short >::value_type temp3 ;
short val3 ;
int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
std::vector< short >::iterator result;
if (!PyArg_ParseTuple(args,(char *)"OOO:_shortArray_insert",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_short_std__allocatorT_short_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_shortArray_insert" "', argument " "1"" of type '" "std::vector< short > *""'");
}
arg1 = reinterpret_cast< std::vector< short > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
if (!SWIG_IsOK(res2) || !iter2) {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "_shortArray_insert" "', argument " "2"" of type '" "std::vector< short >::iterator""'");
} else {
swig::SwigPyIterator_T<std::vector< short >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< short >::iterator > *>(iter2);
if (iter_t) {
arg2 = iter_t->get_current();
} else {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "_shortArray_insert" "', argument " "2"" of type '" "std::vector< short >::iterator""'");
}
}
ecode3 = SWIG_AsVal_short(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "_shortArray_insert" "', argument " "3"" of type '" "std::vector< short >::value_type""'");
}
temp3 = static_cast< std::vector< short >::value_type >(val3);
arg3 = &temp3;
result = std_vector_Sl_short_Sg__insert__SWIG_0(arg1,arg2,(short const &)*arg3);
resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< short >::iterator & >(result)),
swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__shortArray_insert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< short > *arg1 = (std::vector< short > *) 0 ;
std::vector< short >::iterator arg2 ;
std::vector< short >::size_type arg3 ;
std::vector< short >::value_type *arg4 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
swig::SwigPyIterator *iter2 = 0 ;
int res2 ;
size_t val3 ;
int ecode3 = 0 ;
std::vector< short >::value_type temp4 ;
short val4 ;
int ecode4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOO:_shortArray_insert",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_short_std__allocatorT_short_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_shortArray_insert" "', argument " "1"" of type '" "std::vector< short > *""'");
}
arg1 = reinterpret_cast< std::vector< short > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
if (!SWIG_IsOK(res2) || !iter2) {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "_shortArray_insert" "', argument " "2"" of type '" "std::vector< short >::iterator""'");
} else {
swig::SwigPyIterator_T<std::vector< short >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< short >::iterator > *>(iter2);
if (iter_t) {
arg2 = iter_t->get_current();
} else {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "_shortArray_insert" "', argument " "2"" of type '" "std::vector< short >::iterator""'");
}
}
ecode3 = SWIG_AsVal_size_t(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "_shortArray_insert" "', argument " "3"" of type '" "std::vector< short >::size_type""'");
}
arg3 = static_cast< std::vector< short >::size_type >(val3);
ecode4 = SWIG_AsVal_short(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "_shortArray_insert" "', argument " "4"" of type '" "std::vector< short >::value_type""'");
}
temp4 = static_cast< std::vector< short >::value_type >(val4);
arg4 = &temp4;
std_vector_Sl_short_Sg__insert__SWIG_1(arg1,arg2,arg3,(short const &)*arg4);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__shortArray_insert(PyObject *self, PyObject *args) {
Py_ssize_t argc;
PyObject *argv[5] = {
0
};
Py_ssize_t ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = args ? PyObject_Length(args) : 0;
for (ii = 0; (ii < 4) && (ii < argc); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 3) {
int _v;
int res = swig::asptr(argv[0], (std::vector< short,std::allocator< short > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
swig::SwigPyIterator *iter = 0;
int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
_v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< short >::iterator > *>(iter) != 0));
if (_v) {
{
int res = SWIG_AsVal_short(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap__shortArray_insert__SWIG_0(self, args);
}
}
}
}
if (argc == 4) {
int _v;
int res = swig::asptr(argv[0], (std::vector< short,std::allocator< short > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
swig::SwigPyIterator *iter = 0;
int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
_v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< short >::iterator > *>(iter) != 0));
if (_v) {
{
int res = SWIG_AsVal_size_t(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_short(argv[3], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap__shortArray_insert__SWIG_1(self, args);
}
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function '_shortArray_insert'.\n"
" Possible C/C++ prototypes are:\n"
" std::vector< short >::insert(std::vector< short >::iterator,std::vector< short >::value_type const &)\n"
" std::vector< short >::insert(std::vector< short >::iterator,std::vector< short >::size_type,std::vector< short >::value_type const &)\n");
return 0;
}
SWIGINTERN PyObject *_wrap__shortArray_reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< short > *arg1 = (std::vector< short > *) 0 ;
std::vector< short >::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:_shortArray_reserve",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_short_std__allocatorT_short_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_shortArray_reserve" "', argument " "1"" of type '" "std::vector< short > *""'");
}
arg1 = reinterpret_cast< std::vector< short > * >(argp1);
ecode2 = SWIG_AsVal_size_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_shortArray_reserve" "', argument " "2"" of type '" "std::vector< short >::size_type""'");
}
arg2 = static_cast< std::vector< short >::size_type >(val2);
(arg1)->reserve(arg2);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__shortArray_capacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< short > *arg1 = (std::vector< short > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
std::vector< short >::size_type result;
if (!PyArg_ParseTuple(args,(char *)"O:_shortArray_capacity",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_short_std__allocatorT_short_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_shortArray_capacity" "', argument " "1"" of type '" "std::vector< short > const *""'");
}
arg1 = reinterpret_cast< std::vector< short > * >(argp1);
result = ((std::vector< short > const *)arg1)->capacity();
resultobj = SWIG_From_size_t(static_cast< size_t >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete__shortArray(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< short > *arg1 = (std::vector< short > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete__shortArray",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_short_std__allocatorT_short_t_t, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__shortArray" "', argument " "1"" of type '" "std::vector< short > *""'");
}
arg1 = reinterpret_cast< std::vector< short > * >(argp1);
delete arg1;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_shortArray_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_short_std__allocatorT_short_t_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_new__Matx_short_2_1__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
short *arg1 = (short *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
cv::Matx< short,2,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__Matx_short_2_1",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_short, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_short_2_1" "', argument " "1"" of type '" "short const *""'");
}
arg1 = reinterpret_cast< short * >(argp1);
result = (cv::Matx< short,2,1 > *)new cv::Matx< short,2,1 >((short const *)arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_short_2_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_short_2_1_all(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
short arg1 ;
short val1 ;
int ecode1 = 0 ;
PyObject * obj0 = 0 ;
SwigValueWrapper< cv::Matx< short,2,1 > > result;
if (!PyArg_ParseTuple(args,(char *)"O:_Matx_short_2_1_all",&obj0)) SWIG_fail;
ecode1 = SWIG_AsVal_short(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_Matx_short_2_1_all" "', argument " "1"" of type '" "short""'");
}
arg1 = static_cast< short >(val1);
result = cv::Matx< short,2,1 >::SWIGTEMPLATEDISAMBIGUATOR all(arg1);
resultobj = SWIG_NewPointerObj((new cv::Matx< short,2,1 >(static_cast< const cv::Matx< short,2,1 >& >(result))), SWIGTYPE_p_cv__MatxT_short_2_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_short_2_1_zeros(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
SwigValueWrapper< cv::Matx< short,2,1 > > result;
if (!PyArg_ParseTuple(args,(char *)":_Matx_short_2_1_zeros")) SWIG_fail;
result = cv::Matx< short,2,1 >::SWIGTEMPLATEDISAMBIGUATOR zeros();
resultobj = SWIG_NewPointerObj((new cv::Matx< short,2,1 >(static_cast< const cv::Matx< short,2,1 >& >(result))), SWIGTYPE_p_cv__MatxT_short_2_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_short_2_1_ones(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
SwigValueWrapper< cv::Matx< short,2,1 > > result;
if (!PyArg_ParseTuple(args,(char *)":_Matx_short_2_1_ones")) SWIG_fail;
result = cv::Matx< short,2,1 >::SWIGTEMPLATEDISAMBIGUATOR ones();
resultobj = SWIG_NewPointerObj((new cv::Matx< short,2,1 >(static_cast< const cv::Matx< short,2,1 >& >(result))), SWIGTYPE_p_cv__MatxT_short_2_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_short_2_1_eye(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
SwigValueWrapper< cv::Matx< short,2,1 > > result;
if (!PyArg_ParseTuple(args,(char *)":_Matx_short_2_1_eye")) SWIG_fail;
result = cv::Matx< short,2,1 >::SWIGTEMPLATEDISAMBIGUATOR eye();
resultobj = SWIG_NewPointerObj((new cv::Matx< short,2,1 >(static_cast< const cv::Matx< short,2,1 >& >(result))), SWIGTYPE_p_cv__MatxT_short_2_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_short_2_1_randu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
short arg1 ;
short arg2 ;
short val1 ;
int ecode1 = 0 ;
short val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
SwigValueWrapper< cv::Matx< short,2,1 > > result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_short_2_1_randu",&obj0,&obj1)) SWIG_fail;
ecode1 = SWIG_AsVal_short(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_Matx_short_2_1_randu" "', argument " "1"" of type '" "short""'");
}
arg1 = static_cast< short >(val1);
ecode2 = SWIG_AsVal_short(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_Matx_short_2_1_randu" "', argument " "2"" of type '" "short""'");
}
arg2 = static_cast< short >(val2);
result = cv::Matx< short,2,1 >::SWIGTEMPLATEDISAMBIGUATOR randu(arg1,arg2);
resultobj = SWIG_NewPointerObj((new cv::Matx< short,2,1 >(static_cast< const cv::Matx< short,2,1 >& >(result))), SWIGTYPE_p_cv__MatxT_short_2_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_short_2_1_randn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
short arg1 ;
short arg2 ;
short val1 ;
int ecode1 = 0 ;
short val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
SwigValueWrapper< cv::Matx< short,2,1 > > result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_short_2_1_randn",&obj0,&obj1)) SWIG_fail;
ecode1 = SWIG_AsVal_short(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_Matx_short_2_1_randn" "', argument " "1"" of type '" "short""'");
}
arg1 = static_cast< short >(val1);
ecode2 = SWIG_AsVal_short(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_Matx_short_2_1_randn" "', argument " "2"" of type '" "short""'");
}
arg2 = static_cast< short >(val2);
result = cv::Matx< short,2,1 >::SWIGTEMPLATEDISAMBIGUATOR randn(arg1,arg2);
resultobj = SWIG_NewPointerObj((new cv::Matx< short,2,1 >(static_cast< const cv::Matx< short,2,1 >& >(result))), SWIGTYPE_p_cv__MatxT_short_2_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_short_2_1_dot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< short,2,1 > *arg1 = (cv::Matx< short,2,1 > *) 0 ;
cv::Matx< short,2,1 > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
short result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_short_2_1_dot",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_short_2_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_short_2_1_dot" "', argument " "1"" of type '" "cv::Matx< short,2,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< short,2,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_short_2_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_short_2_1_dot" "', argument " "2"" of type '" "cv::Matx< short,2,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Matx_short_2_1_dot" "', argument " "2"" of type '" "cv::Matx< short,2,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< short,2,1 > * >(argp2);
result = (short)((cv::Matx< short,2,1 > const *)arg1)->dot((cv::Matx< short,2,1 > const &)*arg2);
resultobj = SWIG_From_short(static_cast< short >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_short_2_1_ddot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< short,2,1 > *arg1 = (cv::Matx< short,2,1 > *) 0 ;
cv::Matx< short,2,1 > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
double result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_short_2_1_ddot",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_short_2_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_short_2_1_ddot" "', argument " "1"" of type '" "cv::Matx< short,2,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< short,2,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_short_2_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_short_2_1_ddot" "', argument " "2"" of type '" "cv::Matx< short,2,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Matx_short_2_1_ddot" "', argument " "2"" of type '" "cv::Matx< short,2,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< short,2,1 > * >(argp2);
result = (double)((cv::Matx< short,2,1 > const *)arg1)->ddot((cv::Matx< short,2,1 > const &)*arg2);
resultobj = SWIG_From_double(static_cast< double >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_short_2_1_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< short,2,1 > *arg1 = (cv::Matx< short,2,1 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
SwigValueWrapper< cv::Matx< short,1,2 > > result;
if (!PyArg_ParseTuple(args,(char *)"O:_Matx_short_2_1_t",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_short_2_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_short_2_1_t" "', argument " "1"" of type '" "cv::Matx< short,2,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< short,2,1 > * >(argp1);
result = ((cv::Matx< short,2,1 > const *)arg1)->t();
resultobj = SWIG_NewPointerObj((new cv::Matx< short,1,2 >(static_cast< const cv::Matx< short,1,2 >& >(result))), SWIGTYPE_p_cv__MatxT_short_1_2_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_short_2_1_mul(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< short,2,1 > *arg1 = (cv::Matx< short,2,1 > *) 0 ;
cv::Matx< short,2,1 > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
SwigValueWrapper< cv::Matx< short,2,1 > > result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_short_2_1_mul",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_short_2_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_short_2_1_mul" "', argument " "1"" of type '" "cv::Matx< short,2,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< short,2,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_short_2_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_short_2_1_mul" "', argument " "2"" of type '" "cv::Matx< short,2,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Matx_short_2_1_mul" "', argument " "2"" of type '" "cv::Matx< short,2,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< short,2,1 > * >(argp2);
result = ((cv::Matx< short,2,1 > const *)arg1)->mul((cv::Matx< short,2,1 > const &)*arg2);
resultobj = SWIG_NewPointerObj((new cv::Matx< short,2,1 >(static_cast< const cv::Matx< short,2,1 >& >(result))), SWIGTYPE_p_cv__MatxT_short_2_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_short_2_1_div(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< short,2,1 > *arg1 = (cv::Matx< short,2,1 > *) 0 ;
cv::Matx< short,2,1 > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
SwigValueWrapper< cv::Matx< short,2,1 > > result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_short_2_1_div",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_short_2_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_short_2_1_div" "', argument " "1"" of type '" "cv::Matx< short,2,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< short,2,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_short_2_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_short_2_1_div" "', argument " "2"" of type '" "cv::Matx< short,2,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Matx_short_2_1_div" "', argument " "2"" of type '" "cv::Matx< short,2,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< short,2,1 > * >(argp2);
result = ((cv::Matx< short,2,1 > const *)arg1)->div((cv::Matx< short,2,1 > const &)*arg2);
resultobj = SWIG_NewPointerObj((new cv::Matx< short,2,1 >(static_cast< const cv::Matx< short,2,1 >& >(result))), SWIGTYPE_p_cv__MatxT_short_2_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_short_2_1___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< short,2,1 > *arg1 = (cv::Matx< short,2,1 > *) 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 ;
short *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:_Matx_short_2_1___call__",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_short_2_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_short_2_1___call__" "', argument " "1"" of type '" "cv::Matx< short,2,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< short,2,1 > * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_Matx_short_2_1___call__" "', 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 '" "_Matx_short_2_1___call__" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
result = (short *) &((cv::Matx< short,2,1 > const *)arg1)->operator ()(arg2,arg3);
resultobj = SWIG_From_short(static_cast< short >(*result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_short_2_1__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< short,2,1 > *arg1 = 0 ;
cv::Matx< short,2,1 > *arg2 = 0 ;
cv::Matx_AddOp 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 ;
cv::Matx< short,2,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Matx_short_2_1",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_short_2_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_short_2_1" "', argument " "1"" of type '" "cv::Matx< short,2,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_short_2_1" "', argument " "1"" of type '" "cv::Matx< short,2,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< short,2,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_short_2_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Matx_short_2_1" "', argument " "2"" of type '" "cv::Matx< short,2,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_short_2_1" "', argument " "2"" of type '" "cv::Matx< short,2,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< short,2,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_AddOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Matx_short_2_1" "', argument " "3"" of type '" "cv::Matx_AddOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_short_2_1" "', argument " "3"" of type '" "cv::Matx_AddOp""'");
} else {
cv::Matx_AddOp * temp = reinterpret_cast< cv::Matx_AddOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Matx< short,2,1 > *)new cv::Matx< short,2,1 >((cv::Matx< short,2,1 > const &)*arg1,(cv::Matx< short,2,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_short_2_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_short_2_1__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< short,2,1 > *arg1 = 0 ;
cv::Matx< short,2,1 > *arg2 = 0 ;
cv::Matx_SubOp 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 ;
cv::Matx< short,2,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Matx_short_2_1",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_short_2_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_short_2_1" "', argument " "1"" of type '" "cv::Matx< short,2,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_short_2_1" "', argument " "1"" of type '" "cv::Matx< short,2,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< short,2,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_short_2_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Matx_short_2_1" "', argument " "2"" of type '" "cv::Matx< short,2,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_short_2_1" "', argument " "2"" of type '" "cv::Matx< short,2,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< short,2,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_SubOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Matx_short_2_1" "', argument " "3"" of type '" "cv::Matx_SubOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_short_2_1" "', argument " "3"" of type '" "cv::Matx_SubOp""'");
} else {
cv::Matx_SubOp * temp = reinterpret_cast< cv::Matx_SubOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Matx< short,2,1 > *)new cv::Matx< short,2,1 >((cv::Matx< short,2,1 > const &)*arg1,(cv::Matx< short,2,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_short_2_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_short_2_1__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< short,2,1 > *arg1 = 0 ;
cv::Matx< short,2,1 > *arg2 = 0 ;
cv::Matx_MulOp 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 ;
cv::Matx< short,2,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Matx_short_2_1",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_short_2_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_short_2_1" "', argument " "1"" of type '" "cv::Matx< short,2,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_short_2_1" "', argument " "1"" of type '" "cv::Matx< short,2,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< short,2,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_short_2_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Matx_short_2_1" "', argument " "2"" of type '" "cv::Matx< short,2,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_short_2_1" "', argument " "2"" of type '" "cv::Matx< short,2,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< short,2,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_MulOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Matx_short_2_1" "', argument " "3"" of type '" "cv::Matx_MulOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_short_2_1" "', argument " "3"" of type '" "cv::Matx_MulOp""'");
} else {
cv::Matx_MulOp * temp = reinterpret_cast< cv::Matx_MulOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Matx< short,2,1 > *)new cv::Matx< short,2,1 >((cv::Matx< short,2,1 > const &)*arg1,(cv::Matx< short,2,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_short_2_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_short_2_1__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< short,2,1 > *arg1 = 0 ;
cv::Matx< short,2,1 > *arg2 = 0 ;
cv::Matx_DivOp 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 ;
cv::Matx< short,2,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Matx_short_2_1",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_short_2_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_short_2_1" "', argument " "1"" of type '" "cv::Matx< short,2,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_short_2_1" "', argument " "1"" of type '" "cv::Matx< short,2,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< short,2,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_short_2_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Matx_short_2_1" "', argument " "2"" of type '" "cv::Matx< short,2,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_short_2_1" "', argument " "2"" of type '" "cv::Matx< short,2,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< short,2,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_DivOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Matx_short_2_1" "', argument " "3"" of type '" "cv::Matx_DivOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_short_2_1" "', argument " "3"" of type '" "cv::Matx_DivOp""'");
} else {
cv::Matx_DivOp * temp = reinterpret_cast< cv::Matx_DivOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Matx< short,2,1 > *)new cv::Matx< short,2,1 >((cv::Matx< short,2,1 > const &)*arg1,(cv::Matx< short,2,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_short_2_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_short_2_1__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< short,1,2 > *arg1 = 0 ;
cv::Matx_TOp arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
cv::Matx< short,2,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:new__Matx_short_2_1",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_short_1_2_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_short_2_1" "', argument " "1"" of type '" "cv::Matx< short,1,2 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_short_2_1" "', argument " "1"" of type '" "cv::Matx< short,1,2 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< short,1,2 > * >(argp1);
{
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__Matx_TOp, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Matx_short_2_1" "', argument " "2"" of type '" "cv::Matx_TOp""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_short_2_1" "', argument " "2"" of type '" "cv::Matx_TOp""'");
} else {
cv::Matx_TOp * temp = reinterpret_cast< cv::Matx_TOp * >(argp2);
arg2 = *temp;
if (SWIG_IsNewObj(res2)) delete temp;
}
}
result = (cv::Matx< short,2,1 > *)new cv::Matx< short,2,1 >((cv::Matx< short,1,2 > const &)*arg1,arg2);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_short_2_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_short_2_1_val_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< short,2,1 > *arg1 = (cv::Matx< short,2,1 > *) 0 ;
short *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:_Matx_short_2_1_val_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_short_2_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_short_2_1_val_set" "', argument " "1"" of type '" "cv::Matx< short,2,1 > *""'");
}
arg1 = reinterpret_cast< cv::Matx< short,2,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_short, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_short_2_1_val_set" "', argument " "2"" of type '" "short [2*1]""'");
}
arg2 = reinterpret_cast< short * >(argp2);
{
if (arg2) {
size_t ii = 0;
for (; ii < (size_t)2*1; ++ii) *(short *)&arg1->val[ii] = *((short *)arg2 + ii);
} else {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""val""' of type '""short [2*1]""'");
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_short_2_1_val_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< short,2,1 > *arg1 = (cv::Matx< short,2,1 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
short *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:_Matx_short_2_1_val_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_short_2_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_short_2_1_val_get" "', argument " "1"" of type '" "cv::Matx< short,2,1 > *""'");
}
arg1 = reinterpret_cast< cv::Matx< short,2,1 > * >(argp1);
result = (short *)(short *) ((arg1)->val);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_short, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_short_2_1__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< cv::Matx< short,2,1 >::value_type,std::allocator< cv::Matx< short,2,1 >::value_type > > arg1 ;
PyObject * obj0 = 0 ;
cv::Matx< short,2,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__Matx_short_2_1",&obj0)) SWIG_fail;
{
std::vector< short,std::allocator< short > > *ptr = (std::vector< short,std::allocator< short > > *)0;
int res = swig::asptr(obj0, &ptr);
if (!SWIG_IsOK(res) || !ptr) {
SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new__Matx_short_2_1" "', argument " "1"" of type '" "std::vector< cv::Matx< short,2,1 >::value_type,std::allocator< cv::Matx< short,2,1 >::value_type > >""'");
}
arg1 = *ptr;
if (SWIG_IsNewObj(res)) delete ptr;
}
result = (cv::Matx< short,2,1 > *)new_cv_Matx_Sl_short_Sc_2_Sc_1_Sg___SWIG_6(arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_short_2_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_short_2_1(PyObject *self, PyObject *args) {
Py_ssize_t argc;
PyObject *argv[4] = {
0
};
Py_ssize_t ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = args ? PyObject_Length(args) : 0;
for (ii = 0; (ii < 3) && (ii < argc); 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_short, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_short_2_1__SWIG_0(self, args);
}
}
if (argc == 1) {
int _v;
int res = swig::asptr(argv[0], (std::vector< short,std::allocator< short > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_short_2_1__SWIG_6(self, args);
}
}
if (argc == 2) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_short_1_2_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__Matx_TOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_short_2_1__SWIG_5(self, args);
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_short_2_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_short_2_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_MulOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_short_2_1__SWIG_3(self, args);
}
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_short_2_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_short_2_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_DivOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_short_2_1__SWIG_4(self, args);
}
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_short_2_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_short_2_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_AddOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_short_2_1__SWIG_1(self, args);
}
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_short_2_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_short_2_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_SubOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_short_2_1__SWIG_2(self, args);
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new__Matx_short_2_1'.\n"
" Possible C/C++ prototypes are:\n"
" cv::Matx< short,2,1 >::Matx(short const *)\n"
" cv::Matx< short,2,1 >::Matx(cv::Matx< short,2,1 > const &,cv::Matx< short,2,1 > const &,cv::Matx_AddOp)\n"
" cv::Matx< short,2,1 >::Matx(cv::Matx< short,2,1 > const &,cv::Matx< short,2,1 > const &,cv::Matx_SubOp)\n"
" cv::Matx< short,2,1 >::Matx(cv::Matx< short,2,1 > const &,cv::Matx< short,2,1 > const &,cv::Matx_MulOp)\n"
" cv::Matx< short,2,1 >::Matx(cv::Matx< short,2,1 > const &,cv::Matx< short,2,1 > const &,cv::Matx_DivOp)\n"
" cv::Matx< short,2,1 >::Matx(cv::Matx< short,1,2 > const &,cv::Matx_TOp)\n"
" cv::Matx< short,2,1 >::Matx(std::vector< cv::Matx< short,2,1 >::value_type,std::allocator< cv::Matx< short,2,1 >::value_type > >)\n");
return 0;
}
SWIGINTERN PyObject *_wrap__Matx_short_2_1___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< short,2,1 > *arg1 = (cv::Matx< short,2,1 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
std::string result;
if (!PyArg_ParseTuple(args,(char *)"O:_Matx_short_2_1___str__",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_short_2_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_short_2_1___str__" "', argument " "1"" of type '" "cv::Matx< short,2,1 > *""'");
}
arg1 = reinterpret_cast< cv::Matx< short,2,1 > * >(argp1);
result = cv_Matx_Sl_short_Sc_2_Sc_1_Sg____str__(arg1);
resultobj = SWIG_From_std_string(static_cast< std::string >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete__Matx_short_2_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< short,2,1 > *arg1 = (cv::Matx< short,2,1 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete__Matx_short_2_1",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_short_2_1_t, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__Matx_short_2_1" "', argument " "1"" of type '" "cv::Matx< short,2,1 > *""'");
}
arg1 = reinterpret_cast< cv::Matx< short,2,1 > * >(argp1);
delete arg1;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_Matx_short_2_1_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_cv__MatxT_short_2_1_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_new__Vec_short_2__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
short *arg1 = (short *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
cv::Vec< short,2 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__Vec_short_2",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_short, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Vec_short_2" "', argument " "1"" of type '" "short const *""'");
}
arg1 = reinterpret_cast< short * >(argp1);
result = (cv::Vec< short,2 > *)new cv::Vec< short,2 >((short const *)arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__VecT_short_2_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Vec_short_2__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Vec< short,2 > *arg1 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
cv::Vec< short,2 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__Vec_short_2",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__VecT_short_2_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Vec_short_2" "', argument " "1"" of type '" "cv::Vec< short,2 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_short_2" "', argument " "1"" of type '" "cv::Vec< short,2 > const &""'");
}
arg1 = reinterpret_cast< cv::Vec< short,2 > * >(argp1);
result = (cv::Vec< short,2 > *)new cv::Vec< short,2 >((cv::Vec< short,2 > const &)*arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__VecT_short_2_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Vec_short_2_all(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
short arg1 ;
short val1 ;
int ecode1 = 0 ;
PyObject * obj0 = 0 ;
SwigValueWrapper< cv::Vec< short,2 > > result;
if (!PyArg_ParseTuple(args,(char *)"O:_Vec_short_2_all",&obj0)) SWIG_fail;
ecode1 = SWIG_AsVal_short(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_Vec_short_2_all" "', argument " "1"" of type '" "short""'");
}
arg1 = static_cast< short >(val1);
result = cv::Vec< short,2 >::SWIGTEMPLATEDISAMBIGUATOR all(arg1);
resultobj = SWIG_NewPointerObj((new cv::Vec< short,2 >(static_cast< const cv::Vec< short,2 >& >(result))), SWIGTYPE_p_cv__VecT_short_2_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Vec_short_2_mul(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Vec< short,2 > *arg1 = (cv::Vec< short,2 > *) 0 ;
cv::Vec< short,2 > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
SwigValueWrapper< cv::Vec< short,2 > > result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Vec_short_2_mul",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__VecT_short_2_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Vec_short_2_mul" "', argument " "1"" of type '" "cv::Vec< short,2 > const *""'");
}
arg1 = reinterpret_cast< cv::Vec< short,2 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__VecT_short_2_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Vec_short_2_mul" "', argument " "2"" of type '" "cv::Vec< short,2 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Vec_short_2_mul" "', argument " "2"" of type '" "cv::Vec< short,2 > const &""'");
}
arg2 = reinterpret_cast< cv::Vec< short,2 > * >(argp2);
result = ((cv::Vec< short,2 > const *)arg1)->mul((cv::Vec< short,2 > const &)*arg2);
resultobj = SWIG_NewPointerObj((new cv::Vec< short,2 >(static_cast< const cv::Vec< short,2 >& >(result))), SWIGTYPE_p_cv__VecT_short_2_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Vec_short_2___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Vec< short,2 > *arg1 = (cv::Vec< short,2 > *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
short *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:_Vec_short_2___call__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__VecT_short_2_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Vec_short_2___call__" "', argument " "1"" of type '" "cv::Vec< short,2 > const *""'");
}
arg1 = reinterpret_cast< cv::Vec< short,2 > * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_Vec_short_2___call__" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
result = (short *) &((cv::Vec< short,2 > const *)arg1)->operator ()(arg2);
resultobj = SWIG_From_short(static_cast< short >(*result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Vec_short_2__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< short,2,1 > *arg1 = 0 ;
cv::Matx< short,2,1 > *arg2 = 0 ;
cv::Matx_AddOp 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 ;
cv::Vec< short,2 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Vec_short_2",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_short_2_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Vec_short_2" "', argument " "1"" of type '" "cv::Matx< short,2,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_short_2" "', argument " "1"" of type '" "cv::Matx< short,2,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< short,2,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_short_2_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Vec_short_2" "', argument " "2"" of type '" "cv::Matx< short,2,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_short_2" "', argument " "2"" of type '" "cv::Matx< short,2,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< short,2,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_AddOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Vec_short_2" "', argument " "3"" of type '" "cv::Matx_AddOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_short_2" "', argument " "3"" of type '" "cv::Matx_AddOp""'");
} else {
cv::Matx_AddOp * temp = reinterpret_cast< cv::Matx_AddOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Vec< short,2 > *)new cv::Vec< short,2 >((cv::Matx< short,2,1 > const &)*arg1,(cv::Matx< short,2,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__VecT_short_2_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Vec_short_2__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< short,2,1 > *arg1 = 0 ;
cv::Matx< short,2,1 > *arg2 = 0 ;
cv::Matx_SubOp 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 ;
cv::Vec< short,2 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Vec_short_2",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_short_2_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Vec_short_2" "', argument " "1"" of type '" "cv::Matx< short,2,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_short_2" "', argument " "1"" of type '" "cv::Matx< short,2,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< short,2,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_short_2_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Vec_short_2" "', argument " "2"" of type '" "cv::Matx< short,2,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_short_2" "', argument " "2"" of type '" "cv::Matx< short,2,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< short,2,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_SubOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Vec_short_2" "', argument " "3"" of type '" "cv::Matx_SubOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_short_2" "', argument " "3"" of type '" "cv::Matx_SubOp""'");
} else {
cv::Matx_SubOp * temp = reinterpret_cast< cv::Matx_SubOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Vec< short,2 > *)new cv::Vec< short,2 >((cv::Matx< short,2,1 > const &)*arg1,(cv::Matx< short,2,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__VecT_short_2_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Vec_short_2__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< cv::Vec< short,2 >::value_type,std::allocator< cv::Vec< short,2 >::value_type > > arg1 ;
PyObject * obj0 = 0 ;
cv::Vec< short,2 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__Vec_short_2",&obj0)) SWIG_fail;
{
std::vector< short,std::allocator< short > > *ptr = (std::vector< short,std::allocator< short > > *)0;
int res = swig::asptr(obj0, &ptr);
if (!SWIG_IsOK(res) || !ptr) {
SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new__Vec_short_2" "', argument " "1"" of type '" "std::vector< cv::Vec< short,2 >::value_type,std::allocator< cv::Vec< short,2 >::value_type > >""'");
}
arg1 = *ptr;
if (SWIG_IsNewObj(res)) delete ptr;
}
result = (cv::Vec< short,2 > *)new_cv_Vec_Sl_short_Sc_2_Sg___SWIG_4(arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__VecT_short_2_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Vec_short_2(PyObject *self, PyObject *args) {
Py_ssize_t argc;
PyObject *argv[4] = {
0
};
Py_ssize_t ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = args ? PyObject_Length(args) : 0;
for (ii = 0; (ii < 3) && (ii < argc); 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_short, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Vec_short_2__SWIG_0(self, args);
}
}
if (argc == 1) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__VecT_short_2_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Vec_short_2__SWIG_1(self, args);
}
}
if (argc == 1) {
int _v;
int res = swig::asptr(argv[0], (std::vector< short,std::allocator< short > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Vec_short_2__SWIG_4(self, args);
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_short_2_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_short_2_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_SubOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Vec_short_2__SWIG_3(self, args);
}
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_short_2_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_short_2_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_AddOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Vec_short_2__SWIG_2(self, args);
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new__Vec_short_2'.\n"
" Possible C/C++ prototypes are:\n"
" cv::Vec< short,2 >::Vec(short const *)\n"
" cv::Vec< short,2 >::Vec(cv::Vec< short,2 > const &)\n"
" cv::Vec< short,2 >::Vec(cv::Matx< short,2,1 > const &,cv::Matx< short,2,1 > const &,cv::Matx_AddOp)\n"
" cv::Vec< short,2 >::Vec(cv::Matx< short,2,1 > const &,cv::Matx< short,2,1 > const &,cv::Matx_SubOp)\n"
" cv::Vec< short,2 >::Vec(std::vector< cv::Vec< short,2 >::value_type,std::allocator< cv::Vec< short,2 >::value_type > >)\n");
return 0;
}
SWIGINTERN PyObject *_wrap__Vec_short_2___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Vec< short,2 > *arg1 = (cv::Vec< short,2 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
std::string result;
if (!PyArg_ParseTuple(args,(char *)"O:_Vec_short_2___str__",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__VecT_short_2_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Vec_short_2___str__" "', argument " "1"" of type '" "cv::Vec< short,2 > *""'");
}
arg1 = reinterpret_cast< cv::Vec< short,2 > * >(argp1);
result = cv_Vec_Sl_short_Sc_2_Sg____str__(arg1);
resultobj = SWIG_From_std_string(static_cast< std::string >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete__Vec_short_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Vec< short,2 > *arg1 = (cv::Vec< short,2 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete__Vec_short_2",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__VecT_short_2_t, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__Vec_short_2" "', argument " "1"" of type '" "cv::Vec< short,2 > *""'");
}
arg1 = reinterpret_cast< cv::Vec< short,2 > * >(argp1);
delete arg1;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_Vec_short_2_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_cv__VecT_short_2_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_new__DataType_Vec_short_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::DataType< cv::Vec< short,2 > > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new__DataType_Vec_short_2")) SWIG_fail;
result = (cv::DataType< cv::Vec< short,2 > > *)new cv::DataType< cv::Vec< short,2 > >();
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__DataTypeT_cv__VecT_short_2_t_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete__DataType_Vec_short_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::DataType< cv::Vec< short,2 > > *arg1 = (cv::DataType< cv::Vec< short,2 > > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete__DataType_Vec_short_2",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__DataTypeT_cv__VecT_short_2_t_t, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__DataType_Vec_short_2" "', argument " "1"" of type '" "cv::DataType< cv::Vec< short,2 > > *""'");
}
arg1 = reinterpret_cast< cv::DataType< cv::Vec< short,2 > > * >(argp1);
delete arg1;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_DataType_Vec_short_2_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_cv__DataTypeT_cv__VecT_short_2_t_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_new__Matx_short_3_1__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
short *arg1 = (short *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
cv::Matx< short,3,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__Matx_short_3_1",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_short, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_short_3_1" "', argument " "1"" of type '" "short const *""'");
}
arg1 = reinterpret_cast< short * >(argp1);
result = (cv::Matx< short,3,1 > *)new cv::Matx< short,3,1 >((short const *)arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_short_3_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_short_3_1_all(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
short arg1 ;
short val1 ;
int ecode1 = 0 ;
PyObject * obj0 = 0 ;
SwigValueWrapper< cv::Matx< short,3,1 > > result;
if (!PyArg_ParseTuple(args,(char *)"O:_Matx_short_3_1_all",&obj0)) SWIG_fail;
ecode1 = SWIG_AsVal_short(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_Matx_short_3_1_all" "', argument " "1"" of type '" "short""'");
}
arg1 = static_cast< short >(val1);
result = cv::Matx< short,3,1 >::SWIGTEMPLATEDISAMBIGUATOR all(arg1);
resultobj = SWIG_NewPointerObj((new cv::Matx< short,3,1 >(static_cast< const cv::Matx< short,3,1 >& >(result))), SWIGTYPE_p_cv__MatxT_short_3_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_short_3_1_zeros(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
SwigValueWrapper< cv::Matx< short,3,1 > > result;
if (!PyArg_ParseTuple(args,(char *)":_Matx_short_3_1_zeros")) SWIG_fail;
result = cv::Matx< short,3,1 >::SWIGTEMPLATEDISAMBIGUATOR zeros();
resultobj = SWIG_NewPointerObj((new cv::Matx< short,3,1 >(static_cast< const cv::Matx< short,3,1 >& >(result))), SWIGTYPE_p_cv__MatxT_short_3_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_short_3_1_ones(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
SwigValueWrapper< cv::Matx< short,3,1 > > result;
if (!PyArg_ParseTuple(args,(char *)":_Matx_short_3_1_ones")) SWIG_fail;
result = cv::Matx< short,3,1 >::SWIGTEMPLATEDISAMBIGUATOR ones();
resultobj = SWIG_NewPointerObj((new cv::Matx< short,3,1 >(static_cast< const cv::Matx< short,3,1 >& >(result))), SWIGTYPE_p_cv__MatxT_short_3_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_short_3_1_eye(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
SwigValueWrapper< cv::Matx< short,3,1 > > result;
if (!PyArg_ParseTuple(args,(char *)":_Matx_short_3_1_eye")) SWIG_fail;
result = cv::Matx< short,3,1 >::SWIGTEMPLATEDISAMBIGUATOR eye();
resultobj = SWIG_NewPointerObj((new cv::Matx< short,3,1 >(static_cast< const cv::Matx< short,3,1 >& >(result))), SWIGTYPE_p_cv__MatxT_short_3_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_short_3_1_randu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
short arg1 ;
short arg2 ;
short val1 ;
int ecode1 = 0 ;
short val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
SwigValueWrapper< cv::Matx< short,3,1 > > result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_short_3_1_randu",&obj0,&obj1)) SWIG_fail;
ecode1 = SWIG_AsVal_short(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_Matx_short_3_1_randu" "', argument " "1"" of type '" "short""'");
}
arg1 = static_cast< short >(val1);
ecode2 = SWIG_AsVal_short(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_Matx_short_3_1_randu" "', argument " "2"" of type '" "short""'");
}
arg2 = static_cast< short >(val2);
result = cv::Matx< short,3,1 >::SWIGTEMPLATEDISAMBIGUATOR randu(arg1,arg2);
resultobj = SWIG_NewPointerObj((new cv::Matx< short,3,1 >(static_cast< const cv::Matx< short,3,1 >& >(result))), SWIGTYPE_p_cv__MatxT_short_3_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_short_3_1_randn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
short arg1 ;
short arg2 ;
short val1 ;
int ecode1 = 0 ;
short val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
SwigValueWrapper< cv::Matx< short,3,1 > > result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_short_3_1_randn",&obj0,&obj1)) SWIG_fail;
ecode1 = SWIG_AsVal_short(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_Matx_short_3_1_randn" "', argument " "1"" of type '" "short""'");
}
arg1 = static_cast< short >(val1);
ecode2 = SWIG_AsVal_short(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_Matx_short_3_1_randn" "', argument " "2"" of type '" "short""'");
}
arg2 = static_cast< short >(val2);
result = cv::Matx< short,3,1 >::SWIGTEMPLATEDISAMBIGUATOR randn(arg1,arg2);
resultobj = SWIG_NewPointerObj((new cv::Matx< short,3,1 >(static_cast< const cv::Matx< short,3,1 >& >(result))), SWIGTYPE_p_cv__MatxT_short_3_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_short_3_1_dot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< short,3,1 > *arg1 = (cv::Matx< short,3,1 > *) 0 ;
cv::Matx< short,3,1 > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
short result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_short_3_1_dot",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_short_3_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_short_3_1_dot" "', argument " "1"" of type '" "cv::Matx< short,3,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< short,3,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_short_3_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_short_3_1_dot" "', argument " "2"" of type '" "cv::Matx< short,3,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Matx_short_3_1_dot" "', argument " "2"" of type '" "cv::Matx< short,3,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< short,3,1 > * >(argp2);
result = (short)((cv::Matx< short,3,1 > const *)arg1)->dot((cv::Matx< short,3,1 > const &)*arg2);
resultobj = SWIG_From_short(static_cast< short >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_short_3_1_ddot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< short,3,1 > *arg1 = (cv::Matx< short,3,1 > *) 0 ;
cv::Matx< short,3,1 > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
double result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_short_3_1_ddot",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_short_3_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_short_3_1_ddot" "', argument " "1"" of type '" "cv::Matx< short,3,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< short,3,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_short_3_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_short_3_1_ddot" "', argument " "2"" of type '" "cv::Matx< short,3,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Matx_short_3_1_ddot" "', argument " "2"" of type '" "cv::Matx< short,3,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< short,3,1 > * >(argp2);
result = (double)((cv::Matx< short,3,1 > const *)arg1)->ddot((cv::Matx< short,3,1 > const &)*arg2);
resultobj = SWIG_From_double(static_cast< double >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_short_3_1_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< short,3,1 > *arg1 = (cv::Matx< short,3,1 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
SwigValueWrapper< cv::Matx< short,1,3 > > result;
if (!PyArg_ParseTuple(args,(char *)"O:_Matx_short_3_1_t",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_short_3_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_short_3_1_t" "', argument " "1"" of type '" "cv::Matx< short,3,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< short,3,1 > * >(argp1);
result = ((cv::Matx< short,3,1 > const *)arg1)->t();
resultobj = SWIG_NewPointerObj((new cv::Matx< short,1,3 >(static_cast< const cv::Matx< short,1,3 >& >(result))), SWIGTYPE_p_cv__MatxT_short_1_3_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_short_3_1_mul(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< short,3,1 > *arg1 = (cv::Matx< short,3,1 > *) 0 ;
cv::Matx< short,3,1 > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
SwigValueWrapper< cv::Matx< short,3,1 > > result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_short_3_1_mul",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_short_3_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_short_3_1_mul" "', argument " "1"" of type '" "cv::Matx< short,3,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< short,3,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_short_3_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_short_3_1_mul" "', argument " "2"" of type '" "cv::Matx< short,3,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Matx_short_3_1_mul" "', argument " "2"" of type '" "cv::Matx< short,3,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< short,3,1 > * >(argp2);
result = ((cv::Matx< short,3,1 > const *)arg1)->mul((cv::Matx< short,3,1 > const &)*arg2);
resultobj = SWIG_NewPointerObj((new cv::Matx< short,3,1 >(static_cast< const cv::Matx< short,3,1 >& >(result))), SWIGTYPE_p_cv__MatxT_short_3_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_short_3_1_div(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< short,3,1 > *arg1 = (cv::Matx< short,3,1 > *) 0 ;
cv::Matx< short,3,1 > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
SwigValueWrapper< cv::Matx< short,3,1 > > result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_short_3_1_div",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_short_3_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_short_3_1_div" "', argument " "1"" of type '" "cv::Matx< short,3,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< short,3,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_short_3_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_short_3_1_div" "', argument " "2"" of type '" "cv::Matx< short,3,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Matx_short_3_1_div" "', argument " "2"" of type '" "cv::Matx< short,3,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< short,3,1 > * >(argp2);
result = ((cv::Matx< short,3,1 > const *)arg1)->div((cv::Matx< short,3,1 > const &)*arg2);
resultobj = SWIG_NewPointerObj((new cv::Matx< short,3,1 >(static_cast< const cv::Matx< short,3,1 >& >(result))), SWIGTYPE_p_cv__MatxT_short_3_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_short_3_1___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< short,3,1 > *arg1 = (cv::Matx< short,3,1 > *) 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 ;
short *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:_Matx_short_3_1___call__",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_short_3_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_short_3_1___call__" "', argument " "1"" of type '" "cv::Matx< short,3,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< short,3,1 > * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_Matx_short_3_1___call__" "', 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 '" "_Matx_short_3_1___call__" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
result = (short *) &((cv::Matx< short,3,1 > const *)arg1)->operator ()(arg2,arg3);
resultobj = SWIG_From_short(static_cast< short >(*result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_short_3_1__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< short,3,1 > *arg1 = 0 ;
cv::Matx< short,3,1 > *arg2 = 0 ;
cv::Matx_AddOp 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 ;
cv::Matx< short,3,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Matx_short_3_1",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_short_3_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_short_3_1" "', argument " "1"" of type '" "cv::Matx< short,3,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_short_3_1" "', argument " "1"" of type '" "cv::Matx< short,3,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< short,3,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_short_3_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Matx_short_3_1" "', argument " "2"" of type '" "cv::Matx< short,3,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_short_3_1" "', argument " "2"" of type '" "cv::Matx< short,3,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< short,3,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_AddOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Matx_short_3_1" "', argument " "3"" of type '" "cv::Matx_AddOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_short_3_1" "', argument " "3"" of type '" "cv::Matx_AddOp""'");
} else {
cv::Matx_AddOp * temp = reinterpret_cast< cv::Matx_AddOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Matx< short,3,1 > *)new cv::Matx< short,3,1 >((cv::Matx< short,3,1 > const &)*arg1,(cv::Matx< short,3,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_short_3_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_short_3_1__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< short,3,1 > *arg1 = 0 ;
cv::Matx< short,3,1 > *arg2 = 0 ;
cv::Matx_SubOp 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 ;
cv::Matx< short,3,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Matx_short_3_1",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_short_3_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_short_3_1" "', argument " "1"" of type '" "cv::Matx< short,3,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_short_3_1" "', argument " "1"" of type '" "cv::Matx< short,3,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< short,3,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_short_3_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Matx_short_3_1" "', argument " "2"" of type '" "cv::Matx< short,3,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_short_3_1" "', argument " "2"" of type '" "cv::Matx< short,3,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< short,3,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_SubOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Matx_short_3_1" "', argument " "3"" of type '" "cv::Matx_SubOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_short_3_1" "', argument " "3"" of type '" "cv::Matx_SubOp""'");
} else {
cv::Matx_SubOp * temp = reinterpret_cast< cv::Matx_SubOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Matx< short,3,1 > *)new cv::Matx< short,3,1 >((cv::Matx< short,3,1 > const &)*arg1,(cv::Matx< short,3,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_short_3_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_short_3_1__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< short,3,1 > *arg1 = 0 ;
cv::Matx< short,3,1 > *arg2 = 0 ;
cv::Matx_MulOp 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 ;
cv::Matx< short,3,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Matx_short_3_1",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_short_3_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_short_3_1" "', argument " "1"" of type '" "cv::Matx< short,3,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_short_3_1" "', argument " "1"" of type '" "cv::Matx< short,3,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< short,3,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_short_3_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Matx_short_3_1" "', argument " "2"" of type '" "cv::Matx< short,3,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_short_3_1" "', argument " "2"" of type '" "cv::Matx< short,3,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< short,3,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_MulOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Matx_short_3_1" "', argument " "3"" of type '" "cv::Matx_MulOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_short_3_1" "', argument " "3"" of type '" "cv::Matx_MulOp""'");
} else {
cv::Matx_MulOp * temp = reinterpret_cast< cv::Matx_MulOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Matx< short,3,1 > *)new cv::Matx< short,3,1 >((cv::Matx< short,3,1 > const &)*arg1,(cv::Matx< short,3,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_short_3_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_short_3_1__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< short,3,1 > *arg1 = 0 ;
cv::Matx< short,3,1 > *arg2 = 0 ;
cv::Matx_DivOp 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 ;
cv::Matx< short,3,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Matx_short_3_1",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_short_3_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_short_3_1" "', argument " "1"" of type '" "cv::Matx< short,3,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_short_3_1" "', argument " "1"" of type '" "cv::Matx< short,3,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< short,3,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_short_3_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Matx_short_3_1" "', argument " "2"" of type '" "cv::Matx< short,3,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_short_3_1" "', argument " "2"" of type '" "cv::Matx< short,3,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< short,3,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_DivOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Matx_short_3_1" "', argument " "3"" of type '" "cv::Matx_DivOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_short_3_1" "', argument " "3"" of type '" "cv::Matx_DivOp""'");
} else {
cv::Matx_DivOp * temp = reinterpret_cast< cv::Matx_DivOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Matx< short,3,1 > *)new cv::Matx< short,3,1 >((cv::Matx< short,3,1 > const &)*arg1,(cv::Matx< short,3,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_short_3_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_short_3_1__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< short,1,3 > *arg1 = 0 ;
cv::Matx_TOp arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
cv::Matx< short,3,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:new__Matx_short_3_1",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_short_1_3_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_short_3_1" "', argument " "1"" of type '" "cv::Matx< short,1,3 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_short_3_1" "', argument " "1"" of type '" "cv::Matx< short,1,3 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< short,1,3 > * >(argp1);
{
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__Matx_TOp, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Matx_short_3_1" "', argument " "2"" of type '" "cv::Matx_TOp""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_short_3_1" "', argument " "2"" of type '" "cv::Matx_TOp""'");
} else {
cv::Matx_TOp * temp = reinterpret_cast< cv::Matx_TOp * >(argp2);
arg2 = *temp;
if (SWIG_IsNewObj(res2)) delete temp;
}
}
result = (cv::Matx< short,3,1 > *)new cv::Matx< short,3,1 >((cv::Matx< short,1,3 > const &)*arg1,arg2);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_short_3_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_short_3_1_val_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< short,3,1 > *arg1 = (cv::Matx< short,3,1 > *) 0 ;
short *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:_Matx_short_3_1_val_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_short_3_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_short_3_1_val_set" "', argument " "1"" of type '" "cv::Matx< short,3,1 > *""'");
}
arg1 = reinterpret_cast< cv::Matx< short,3,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_short, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_short_3_1_val_set" "', argument " "2"" of type '" "short [3*1]""'");
}
arg2 = reinterpret_cast< short * >(argp2);
{
if (arg2) {
size_t ii = 0;
for (; ii < (size_t)3*1; ++ii) *(short *)&arg1->val[ii] = *((short *)arg2 + ii);
} else {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""val""' of type '""short [3*1]""'");
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_short_3_1_val_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< short,3,1 > *arg1 = (cv::Matx< short,3,1 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
short *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:_Matx_short_3_1_val_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_short_3_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_short_3_1_val_get" "', argument " "1"" of type '" "cv::Matx< short,3,1 > *""'");
}
arg1 = reinterpret_cast< cv::Matx< short,3,1 > * >(argp1);
result = (short *)(short *) ((arg1)->val);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_short, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_short_3_1__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< cv::Matx< short,3,1 >::value_type,std::allocator< cv::Matx< short,3,1 >::value_type > > arg1 ;
PyObject * obj0 = 0 ;
cv::Matx< short,3,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__Matx_short_3_1",&obj0)) SWIG_fail;
{
std::vector< short,std::allocator< short > > *ptr = (std::vector< short,std::allocator< short > > *)0;
int res = swig::asptr(obj0, &ptr);
if (!SWIG_IsOK(res) || !ptr) {
SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new__Matx_short_3_1" "', argument " "1"" of type '" "std::vector< cv::Matx< short,3,1 >::value_type,std::allocator< cv::Matx< short,3,1 >::value_type > >""'");
}
arg1 = *ptr;
if (SWIG_IsNewObj(res)) delete ptr;
}
result = (cv::Matx< short,3,1 > *)new_cv_Matx_Sl_short_Sc_3_Sc_1_Sg___SWIG_6(arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_short_3_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_short_3_1(PyObject *self, PyObject *args) {
Py_ssize_t argc;
PyObject *argv[4] = {
0
};
Py_ssize_t ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = args ? PyObject_Length(args) : 0;
for (ii = 0; (ii < 3) && (ii < argc); 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_short, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_short_3_1__SWIG_0(self, args);
}
}
if (argc == 1) {
int _v;
int res = swig::asptr(argv[0], (std::vector< short,std::allocator< short > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_short_3_1__SWIG_6(self, args);
}
}
if (argc == 2) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_short_1_3_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__Matx_TOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_short_3_1__SWIG_5(self, args);
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_short_3_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_short_3_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_MulOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_short_3_1__SWIG_3(self, args);
}
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_short_3_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_short_3_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_DivOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_short_3_1__SWIG_4(self, args);
}
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_short_3_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_short_3_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_AddOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_short_3_1__SWIG_1(self, args);
}
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_short_3_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_short_3_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_SubOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_short_3_1__SWIG_2(self, args);
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new__Matx_short_3_1'.\n"
" Possible C/C++ prototypes are:\n"
" cv::Matx< short,3,1 >::Matx(short const *)\n"
" cv::Matx< short,3,1 >::Matx(cv::Matx< short,3,1 > const &,cv::Matx< short,3,1 > const &,cv::Matx_AddOp)\n"
" cv::Matx< short,3,1 >::Matx(cv::Matx< short,3,1 > const &,cv::Matx< short,3,1 > const &,cv::Matx_SubOp)\n"
" cv::Matx< short,3,1 >::Matx(cv::Matx< short,3,1 > const &,cv::Matx< short,3,1 > const &,cv::Matx_MulOp)\n"
" cv::Matx< short,3,1 >::Matx(cv::Matx< short,3,1 > const &,cv::Matx< short,3,1 > const &,cv::Matx_DivOp)\n"
" cv::Matx< short,3,1 >::Matx(cv::Matx< short,1,3 > const &,cv::Matx_TOp)\n"
" cv::Matx< short,3,1 >::Matx(std::vector< cv::Matx< short,3,1 >::value_type,std::allocator< cv::Matx< short,3,1 >::value_type > >)\n");
return 0;
}
SWIGINTERN PyObject *_wrap__Matx_short_3_1___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< short,3,1 > *arg1 = (cv::Matx< short,3,1 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
std::string result;
if (!PyArg_ParseTuple(args,(char *)"O:_Matx_short_3_1___str__",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_short_3_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_short_3_1___str__" "', argument " "1"" of type '" "cv::Matx< short,3,1 > *""'");
}
arg1 = reinterpret_cast< cv::Matx< short,3,1 > * >(argp1);
result = cv_Matx_Sl_short_Sc_3_Sc_1_Sg____str__(arg1);
resultobj = SWIG_From_std_string(static_cast< std::string >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete__Matx_short_3_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< short,3,1 > *arg1 = (cv::Matx< short,3,1 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete__Matx_short_3_1",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_short_3_1_t, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__Matx_short_3_1" "', argument " "1"" of type '" "cv::Matx< short,3,1 > *""'");
}
arg1 = reinterpret_cast< cv::Matx< short,3,1 > * >(argp1);
delete arg1;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_Matx_short_3_1_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_cv__MatxT_short_3_1_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_new__Vec_short_3__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
short *arg1 = (short *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
cv::Vec< short,3 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__Vec_short_3",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_short, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Vec_short_3" "', argument " "1"" of type '" "short const *""'");
}
arg1 = reinterpret_cast< short * >(argp1);
result = (cv::Vec< short,3 > *)new cv::Vec< short,3 >((short const *)arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__VecT_short_3_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Vec_short_3__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Vec< short,3 > *arg1 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
cv::Vec< short,3 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__Vec_short_3",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__VecT_short_3_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Vec_short_3" "', argument " "1"" of type '" "cv::Vec< short,3 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_short_3" "', argument " "1"" of type '" "cv::Vec< short,3 > const &""'");
}
arg1 = reinterpret_cast< cv::Vec< short,3 > * >(argp1);
result = (cv::Vec< short,3 > *)new cv::Vec< short,3 >((cv::Vec< short,3 > const &)*arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__VecT_short_3_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Vec_short_3_all(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
short arg1 ;
short val1 ;
int ecode1 = 0 ;
PyObject * obj0 = 0 ;
SwigValueWrapper< cv::Vec< short,3 > > result;
if (!PyArg_ParseTuple(args,(char *)"O:_Vec_short_3_all",&obj0)) SWIG_fail;
ecode1 = SWIG_AsVal_short(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_Vec_short_3_all" "', argument " "1"" of type '" "short""'");
}
arg1 = static_cast< short >(val1);
result = cv::Vec< short,3 >::SWIGTEMPLATEDISAMBIGUATOR all(arg1);
resultobj = SWIG_NewPointerObj((new cv::Vec< short,3 >(static_cast< const cv::Vec< short,3 >& >(result))), SWIGTYPE_p_cv__VecT_short_3_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Vec_short_3_mul(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Vec< short,3 > *arg1 = (cv::Vec< short,3 > *) 0 ;
cv::Vec< short,3 > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
SwigValueWrapper< cv::Vec< short,3 > > result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Vec_short_3_mul",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__VecT_short_3_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Vec_short_3_mul" "', argument " "1"" of type '" "cv::Vec< short,3 > const *""'");
}
arg1 = reinterpret_cast< cv::Vec< short,3 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__VecT_short_3_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Vec_short_3_mul" "', argument " "2"" of type '" "cv::Vec< short,3 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Vec_short_3_mul" "', argument " "2"" of type '" "cv::Vec< short,3 > const &""'");
}
arg2 = reinterpret_cast< cv::Vec< short,3 > * >(argp2);
result = ((cv::Vec< short,3 > const *)arg1)->mul((cv::Vec< short,3 > const &)*arg2);
resultobj = SWIG_NewPointerObj((new cv::Vec< short,3 >(static_cast< const cv::Vec< short,3 >& >(result))), SWIGTYPE_p_cv__VecT_short_3_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Vec_short_3___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Vec< short,3 > *arg1 = (cv::Vec< short,3 > *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
short *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:_Vec_short_3___call__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__VecT_short_3_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Vec_short_3___call__" "', argument " "1"" of type '" "cv::Vec< short,3 > const *""'");
}
arg1 = reinterpret_cast< cv::Vec< short,3 > * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_Vec_short_3___call__" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
result = (short *) &((cv::Vec< short,3 > const *)arg1)->operator ()(arg2);
resultobj = SWIG_From_short(static_cast< short >(*result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Vec_short_3__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< short,3,1 > *arg1 = 0 ;
cv::Matx< short,3,1 > *arg2 = 0 ;
cv::Matx_AddOp 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 ;
cv::Vec< short,3 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Vec_short_3",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_short_3_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Vec_short_3" "', argument " "1"" of type '" "cv::Matx< short,3,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_short_3" "', argument " "1"" of type '" "cv::Matx< short,3,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< short,3,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_short_3_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Vec_short_3" "', argument " "2"" of type '" "cv::Matx< short,3,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_short_3" "', argument " "2"" of type '" "cv::Matx< short,3,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< short,3,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_AddOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Vec_short_3" "', argument " "3"" of type '" "cv::Matx_AddOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_short_3" "', argument " "3"" of type '" "cv::Matx_AddOp""'");
} else {
cv::Matx_AddOp * temp = reinterpret_cast< cv::Matx_AddOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Vec< short,3 > *)new cv::Vec< short,3 >((cv::Matx< short,3,1 > const &)*arg1,(cv::Matx< short,3,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__VecT_short_3_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Vec_short_3__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< short,3,1 > *arg1 = 0 ;
cv::Matx< short,3,1 > *arg2 = 0 ;
cv::Matx_SubOp 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 ;
cv::Vec< short,3 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Vec_short_3",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_short_3_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Vec_short_3" "', argument " "1"" of type '" "cv::Matx< short,3,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_short_3" "', argument " "1"" of type '" "cv::Matx< short,3,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< short,3,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_short_3_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Vec_short_3" "', argument " "2"" of type '" "cv::Matx< short,3,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_short_3" "', argument " "2"" of type '" "cv::Matx< short,3,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< short,3,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_SubOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Vec_short_3" "', argument " "3"" of type '" "cv::Matx_SubOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_short_3" "', argument " "3"" of type '" "cv::Matx_SubOp""'");
} else {
cv::Matx_SubOp * temp = reinterpret_cast< cv::Matx_SubOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Vec< short,3 > *)new cv::Vec< short,3 >((cv::Matx< short,3,1 > const &)*arg1,(cv::Matx< short,3,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__VecT_short_3_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Vec_short_3__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< cv::Vec< short,3 >::value_type,std::allocator< cv::Vec< short,3 >::value_type > > arg1 ;
PyObject * obj0 = 0 ;
cv::Vec< short,3 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__Vec_short_3",&obj0)) SWIG_fail;
{
std::vector< short,std::allocator< short > > *ptr = (std::vector< short,std::allocator< short > > *)0;
int res = swig::asptr(obj0, &ptr);
if (!SWIG_IsOK(res) || !ptr) {
SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new__Vec_short_3" "', argument " "1"" of type '" "std::vector< cv::Vec< short,3 >::value_type,std::allocator< cv::Vec< short,3 >::value_type > >""'");
}
arg1 = *ptr;
if (SWIG_IsNewObj(res)) delete ptr;
}
result = (cv::Vec< short,3 > *)new_cv_Vec_Sl_short_Sc_3_Sg___SWIG_4(arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__VecT_short_3_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Vec_short_3(PyObject *self, PyObject *args) {
Py_ssize_t argc;
PyObject *argv[4] = {
0
};
Py_ssize_t ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = args ? PyObject_Length(args) : 0;
for (ii = 0; (ii < 3) && (ii < argc); 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_short, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Vec_short_3__SWIG_0(self, args);
}
}
if (argc == 1) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__VecT_short_3_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Vec_short_3__SWIG_1(self, args);
}
}
if (argc == 1) {
int _v;
int res = swig::asptr(argv[0], (std::vector< short,std::allocator< short > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Vec_short_3__SWIG_4(self, args);
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_short_3_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_short_3_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_SubOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Vec_short_3__SWIG_3(self, args);
}
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_short_3_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_short_3_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_AddOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Vec_short_3__SWIG_2(self, args);
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new__Vec_short_3'.\n"
" Possible C/C++ prototypes are:\n"
" cv::Vec< short,3 >::Vec(short const *)\n"
" cv::Vec< short,3 >::Vec(cv::Vec< short,3 > const &)\n"
" cv::Vec< short,3 >::Vec(cv::Matx< short,3,1 > const &,cv::Matx< short,3,1 > const &,cv::Matx_AddOp)\n"
" cv::Vec< short,3 >::Vec(cv::Matx< short,3,1 > const &,cv::Matx< short,3,1 > const &,cv::Matx_SubOp)\n"
" cv::Vec< short,3 >::Vec(std::vector< cv::Vec< short,3 >::value_type,std::allocator< cv::Vec< short,3 >::value_type > >)\n");
return 0;
}
SWIGINTERN PyObject *_wrap__Vec_short_3___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Vec< short,3 > *arg1 = (cv::Vec< short,3 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
std::string result;
if (!PyArg_ParseTuple(args,(char *)"O:_Vec_short_3___str__",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__VecT_short_3_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Vec_short_3___str__" "', argument " "1"" of type '" "cv::Vec< short,3 > *""'");
}
arg1 = reinterpret_cast< cv::Vec< short,3 > * >(argp1);
result = cv_Vec_Sl_short_Sc_3_Sg____str__(arg1);
resultobj = SWIG_From_std_string(static_cast< std::string >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete__Vec_short_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Vec< short,3 > *arg1 = (cv::Vec< short,3 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete__Vec_short_3",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__VecT_short_3_t, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__Vec_short_3" "', argument " "1"" of type '" "cv::Vec< short,3 > *""'");
}
arg1 = reinterpret_cast< cv::Vec< short,3 > * >(argp1);
delete arg1;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_Vec_short_3_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_cv__VecT_short_3_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_new__DataType_Vec_short_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::DataType< cv::Vec< short,3 > > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new__DataType_Vec_short_3")) SWIG_fail;
result = (cv::DataType< cv::Vec< short,3 > > *)new cv::DataType< cv::Vec< short,3 > >();
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__DataTypeT_cv__VecT_short_3_t_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete__DataType_Vec_short_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::DataType< cv::Vec< short,3 > > *arg1 = (cv::DataType< cv::Vec< short,3 > > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete__DataType_Vec_short_3",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__DataTypeT_cv__VecT_short_3_t_t, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__DataType_Vec_short_3" "', argument " "1"" of type '" "cv::DataType< cv::Vec< short,3 > > *""'");
}
arg1 = reinterpret_cast< cv::DataType< cv::Vec< short,3 > > * >(argp1);
delete arg1;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_DataType_Vec_short_3_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_cv__DataTypeT_cv__VecT_short_3_t_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_new__Matx_short_4_1__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
short *arg1 = (short *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
cv::Matx< short,4,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__Matx_short_4_1",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_short, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_short_4_1" "', argument " "1"" of type '" "short const *""'");
}
arg1 = reinterpret_cast< short * >(argp1);
result = (cv::Matx< short,4,1 > *)new cv::Matx< short,4,1 >((short const *)arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_short_4_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_short_4_1_all(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
short arg1 ;
short val1 ;
int ecode1 = 0 ;
PyObject * obj0 = 0 ;
SwigValueWrapper< cv::Matx< short,4,1 > > result;
if (!PyArg_ParseTuple(args,(char *)"O:_Matx_short_4_1_all",&obj0)) SWIG_fail;
ecode1 = SWIG_AsVal_short(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_Matx_short_4_1_all" "', argument " "1"" of type '" "short""'");
}
arg1 = static_cast< short >(val1);
result = cv::Matx< short,4,1 >::SWIGTEMPLATEDISAMBIGUATOR all(arg1);
resultobj = SWIG_NewPointerObj((new cv::Matx< short,4,1 >(static_cast< const cv::Matx< short,4,1 >& >(result))), SWIGTYPE_p_cv__MatxT_short_4_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_short_4_1_zeros(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
SwigValueWrapper< cv::Matx< short,4,1 > > result;
if (!PyArg_ParseTuple(args,(char *)":_Matx_short_4_1_zeros")) SWIG_fail;
result = cv::Matx< short,4,1 >::SWIGTEMPLATEDISAMBIGUATOR zeros();
resultobj = SWIG_NewPointerObj((new cv::Matx< short,4,1 >(static_cast< const cv::Matx< short,4,1 >& >(result))), SWIGTYPE_p_cv__MatxT_short_4_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_short_4_1_ones(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
SwigValueWrapper< cv::Matx< short,4,1 > > result;
if (!PyArg_ParseTuple(args,(char *)":_Matx_short_4_1_ones")) SWIG_fail;
result = cv::Matx< short,4,1 >::SWIGTEMPLATEDISAMBIGUATOR ones();
resultobj = SWIG_NewPointerObj((new cv::Matx< short,4,1 >(static_cast< const cv::Matx< short,4,1 >& >(result))), SWIGTYPE_p_cv__MatxT_short_4_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_short_4_1_eye(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
SwigValueWrapper< cv::Matx< short,4,1 > > result;
if (!PyArg_ParseTuple(args,(char *)":_Matx_short_4_1_eye")) SWIG_fail;
result = cv::Matx< short,4,1 >::SWIGTEMPLATEDISAMBIGUATOR eye();
resultobj = SWIG_NewPointerObj((new cv::Matx< short,4,1 >(static_cast< const cv::Matx< short,4,1 >& >(result))), SWIGTYPE_p_cv__MatxT_short_4_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_short_4_1_randu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
short arg1 ;
short arg2 ;
short val1 ;
int ecode1 = 0 ;
short val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
SwigValueWrapper< cv::Matx< short,4,1 > > result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_short_4_1_randu",&obj0,&obj1)) SWIG_fail;
ecode1 = SWIG_AsVal_short(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_Matx_short_4_1_randu" "', argument " "1"" of type '" "short""'");
}
arg1 = static_cast< short >(val1);
ecode2 = SWIG_AsVal_short(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_Matx_short_4_1_randu" "', argument " "2"" of type '" "short""'");
}
arg2 = static_cast< short >(val2);
result = cv::Matx< short,4,1 >::SWIGTEMPLATEDISAMBIGUATOR randu(arg1,arg2);
resultobj = SWIG_NewPointerObj((new cv::Matx< short,4,1 >(static_cast< const cv::Matx< short,4,1 >& >(result))), SWIGTYPE_p_cv__MatxT_short_4_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_short_4_1_randn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
short arg1 ;
short arg2 ;
short val1 ;
int ecode1 = 0 ;
short val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
SwigValueWrapper< cv::Matx< short,4,1 > > result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_short_4_1_randn",&obj0,&obj1)) SWIG_fail;
ecode1 = SWIG_AsVal_short(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_Matx_short_4_1_randn" "', argument " "1"" of type '" "short""'");
}
arg1 = static_cast< short >(val1);
ecode2 = SWIG_AsVal_short(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_Matx_short_4_1_randn" "', argument " "2"" of type '" "short""'");
}
arg2 = static_cast< short >(val2);
result = cv::Matx< short,4,1 >::SWIGTEMPLATEDISAMBIGUATOR randn(arg1,arg2);
resultobj = SWIG_NewPointerObj((new cv::Matx< short,4,1 >(static_cast< const cv::Matx< short,4,1 >& >(result))), SWIGTYPE_p_cv__MatxT_short_4_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_short_4_1_dot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< short,4,1 > *arg1 = (cv::Matx< short,4,1 > *) 0 ;
cv::Matx< short,4,1 > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
short result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_short_4_1_dot",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_short_4_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_short_4_1_dot" "', argument " "1"" of type '" "cv::Matx< short,4,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< short,4,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_short_4_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_short_4_1_dot" "', argument " "2"" of type '" "cv::Matx< short,4,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Matx_short_4_1_dot" "', argument " "2"" of type '" "cv::Matx< short,4,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< short,4,1 > * >(argp2);
result = (short)((cv::Matx< short,4,1 > const *)arg1)->dot((cv::Matx< short,4,1 > const &)*arg2);
resultobj = SWIG_From_short(static_cast< short >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_short_4_1_ddot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< short,4,1 > *arg1 = (cv::Matx< short,4,1 > *) 0 ;
cv::Matx< short,4,1 > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
double result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_short_4_1_ddot",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_short_4_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_short_4_1_ddot" "', argument " "1"" of type '" "cv::Matx< short,4,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< short,4,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_short_4_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_short_4_1_ddot" "', argument " "2"" of type '" "cv::Matx< short,4,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Matx_short_4_1_ddot" "', argument " "2"" of type '" "cv::Matx< short,4,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< short,4,1 > * >(argp2);
result = (double)((cv::Matx< short,4,1 > const *)arg1)->ddot((cv::Matx< short,4,1 > const &)*arg2);
resultobj = SWIG_From_double(static_cast< double >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_short_4_1_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< short,4,1 > *arg1 = (cv::Matx< short,4,1 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
SwigValueWrapper< cv::Matx< short,1,4 > > result;
if (!PyArg_ParseTuple(args,(char *)"O:_Matx_short_4_1_t",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_short_4_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_short_4_1_t" "', argument " "1"" of type '" "cv::Matx< short,4,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< short,4,1 > * >(argp1);
result = ((cv::Matx< short,4,1 > const *)arg1)->t();
resultobj = SWIG_NewPointerObj((new cv::Matx< short,1,4 >(static_cast< const cv::Matx< short,1,4 >& >(result))), SWIGTYPE_p_cv__MatxT_short_1_4_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_short_4_1_mul(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< short,4,1 > *arg1 = (cv::Matx< short,4,1 > *) 0 ;
cv::Matx< short,4,1 > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
SwigValueWrapper< cv::Matx< short,4,1 > > result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_short_4_1_mul",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_short_4_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_short_4_1_mul" "', argument " "1"" of type '" "cv::Matx< short,4,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< short,4,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_short_4_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_short_4_1_mul" "', argument " "2"" of type '" "cv::Matx< short,4,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Matx_short_4_1_mul" "', argument " "2"" of type '" "cv::Matx< short,4,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< short,4,1 > * >(argp2);
result = ((cv::Matx< short,4,1 > const *)arg1)->mul((cv::Matx< short,4,1 > const &)*arg2);
resultobj = SWIG_NewPointerObj((new cv::Matx< short,4,1 >(static_cast< const cv::Matx< short,4,1 >& >(result))), SWIGTYPE_p_cv__MatxT_short_4_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_short_4_1_div(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< short,4,1 > *arg1 = (cv::Matx< short,4,1 > *) 0 ;
cv::Matx< short,4,1 > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
SwigValueWrapper< cv::Matx< short,4,1 > > result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_short_4_1_div",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_short_4_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_short_4_1_div" "', argument " "1"" of type '" "cv::Matx< short,4,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< short,4,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_short_4_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_short_4_1_div" "', argument " "2"" of type '" "cv::Matx< short,4,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Matx_short_4_1_div" "', argument " "2"" of type '" "cv::Matx< short,4,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< short,4,1 > * >(argp2);
result = ((cv::Matx< short,4,1 > const *)arg1)->div((cv::Matx< short,4,1 > const &)*arg2);
resultobj = SWIG_NewPointerObj((new cv::Matx< short,4,1 >(static_cast< const cv::Matx< short,4,1 >& >(result))), SWIGTYPE_p_cv__MatxT_short_4_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_short_4_1___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< short,4,1 > *arg1 = (cv::Matx< short,4,1 > *) 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 ;
short *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:_Matx_short_4_1___call__",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_short_4_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_short_4_1___call__" "', argument " "1"" of type '" "cv::Matx< short,4,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< short,4,1 > * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_Matx_short_4_1___call__" "', 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 '" "_Matx_short_4_1___call__" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
result = (short *) &((cv::Matx< short,4,1 > const *)arg1)->operator ()(arg2,arg3);
resultobj = SWIG_From_short(static_cast< short >(*result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_short_4_1__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< short,4,1 > *arg1 = 0 ;
cv::Matx< short,4,1 > *arg2 = 0 ;
cv::Matx_AddOp 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 ;
cv::Matx< short,4,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Matx_short_4_1",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_short_4_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_short_4_1" "', argument " "1"" of type '" "cv::Matx< short,4,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_short_4_1" "', argument " "1"" of type '" "cv::Matx< short,4,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< short,4,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_short_4_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Matx_short_4_1" "', argument " "2"" of type '" "cv::Matx< short,4,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_short_4_1" "', argument " "2"" of type '" "cv::Matx< short,4,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< short,4,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_AddOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Matx_short_4_1" "', argument " "3"" of type '" "cv::Matx_AddOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_short_4_1" "', argument " "3"" of type '" "cv::Matx_AddOp""'");
} else {
cv::Matx_AddOp * temp = reinterpret_cast< cv::Matx_AddOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Matx< short,4,1 > *)new cv::Matx< short,4,1 >((cv::Matx< short,4,1 > const &)*arg1,(cv::Matx< short,4,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_short_4_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_short_4_1__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< short,4,1 > *arg1 = 0 ;
cv::Matx< short,4,1 > *arg2 = 0 ;
cv::Matx_SubOp 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 ;
cv::Matx< short,4,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Matx_short_4_1",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_short_4_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_short_4_1" "', argument " "1"" of type '" "cv::Matx< short,4,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_short_4_1" "', argument " "1"" of type '" "cv::Matx< short,4,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< short,4,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_short_4_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Matx_short_4_1" "', argument " "2"" of type '" "cv::Matx< short,4,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_short_4_1" "', argument " "2"" of type '" "cv::Matx< short,4,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< short,4,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_SubOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Matx_short_4_1" "', argument " "3"" of type '" "cv::Matx_SubOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_short_4_1" "', argument " "3"" of type '" "cv::Matx_SubOp""'");
} else {
cv::Matx_SubOp * temp = reinterpret_cast< cv::Matx_SubOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Matx< short,4,1 > *)new cv::Matx< short,4,1 >((cv::Matx< short,4,1 > const &)*arg1,(cv::Matx< short,4,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_short_4_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_short_4_1__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< short,4,1 > *arg1 = 0 ;
cv::Matx< short,4,1 > *arg2 = 0 ;
cv::Matx_MulOp 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 ;
cv::Matx< short,4,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Matx_short_4_1",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_short_4_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_short_4_1" "', argument " "1"" of type '" "cv::Matx< short,4,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_short_4_1" "', argument " "1"" of type '" "cv::Matx< short,4,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< short,4,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_short_4_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Matx_short_4_1" "', argument " "2"" of type '" "cv::Matx< short,4,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_short_4_1" "', argument " "2"" of type '" "cv::Matx< short,4,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< short,4,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_MulOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Matx_short_4_1" "', argument " "3"" of type '" "cv::Matx_MulOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_short_4_1" "', argument " "3"" of type '" "cv::Matx_MulOp""'");
} else {
cv::Matx_MulOp * temp = reinterpret_cast< cv::Matx_MulOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Matx< short,4,1 > *)new cv::Matx< short,4,1 >((cv::Matx< short,4,1 > const &)*arg1,(cv::Matx< short,4,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_short_4_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_short_4_1__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< short,4,1 > *arg1 = 0 ;
cv::Matx< short,4,1 > *arg2 = 0 ;
cv::Matx_DivOp 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 ;
cv::Matx< short,4,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Matx_short_4_1",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_short_4_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_short_4_1" "', argument " "1"" of type '" "cv::Matx< short,4,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_short_4_1" "', argument " "1"" of type '" "cv::Matx< short,4,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< short,4,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_short_4_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Matx_short_4_1" "', argument " "2"" of type '" "cv::Matx< short,4,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_short_4_1" "', argument " "2"" of type '" "cv::Matx< short,4,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< short,4,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_DivOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Matx_short_4_1" "', argument " "3"" of type '" "cv::Matx_DivOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_short_4_1" "', argument " "3"" of type '" "cv::Matx_DivOp""'");
} else {
cv::Matx_DivOp * temp = reinterpret_cast< cv::Matx_DivOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Matx< short,4,1 > *)new cv::Matx< short,4,1 >((cv::Matx< short,4,1 > const &)*arg1,(cv::Matx< short,4,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_short_4_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_short_4_1__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< short,1,4 > *arg1 = 0 ;
cv::Matx_TOp arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
cv::Matx< short,4,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:new__Matx_short_4_1",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_short_1_4_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_short_4_1" "', argument " "1"" of type '" "cv::Matx< short,1,4 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_short_4_1" "', argument " "1"" of type '" "cv::Matx< short,1,4 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< short,1,4 > * >(argp1);
{
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__Matx_TOp, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Matx_short_4_1" "', argument " "2"" of type '" "cv::Matx_TOp""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_short_4_1" "', argument " "2"" of type '" "cv::Matx_TOp""'");
} else {
cv::Matx_TOp * temp = reinterpret_cast< cv::Matx_TOp * >(argp2);
arg2 = *temp;
if (SWIG_IsNewObj(res2)) delete temp;
}
}
result = (cv::Matx< short,4,1 > *)new cv::Matx< short,4,1 >((cv::Matx< short,1,4 > const &)*arg1,arg2);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_short_4_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_short_4_1_val_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< short,4,1 > *arg1 = (cv::Matx< short,4,1 > *) 0 ;
short *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:_Matx_short_4_1_val_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_short_4_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_short_4_1_val_set" "', argument " "1"" of type '" "cv::Matx< short,4,1 > *""'");
}
arg1 = reinterpret_cast< cv::Matx< short,4,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_short, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_short_4_1_val_set" "', argument " "2"" of type '" "short [4*1]""'");
}
arg2 = reinterpret_cast< short * >(argp2);
{
if (arg2) {
size_t ii = 0;
for (; ii < (size_t)4*1; ++ii) *(short *)&arg1->val[ii] = *((short *)arg2 + ii);
} else {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""val""' of type '""short [4*1]""'");
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_short_4_1_val_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< short,4,1 > *arg1 = (cv::Matx< short,4,1 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
short *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:_Matx_short_4_1_val_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_short_4_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_short_4_1_val_get" "', argument " "1"" of type '" "cv::Matx< short,4,1 > *""'");
}
arg1 = reinterpret_cast< cv::Matx< short,4,1 > * >(argp1);
result = (short *)(short *) ((arg1)->val);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_short, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_short_4_1__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< cv::Matx< short,4,1 >::value_type,std::allocator< cv::Matx< short,4,1 >::value_type > > arg1 ;
PyObject * obj0 = 0 ;
cv::Matx< short,4,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__Matx_short_4_1",&obj0)) SWIG_fail;
{
std::vector< short,std::allocator< short > > *ptr = (std::vector< short,std::allocator< short > > *)0;
int res = swig::asptr(obj0, &ptr);
if (!SWIG_IsOK(res) || !ptr) {
SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new__Matx_short_4_1" "', argument " "1"" of type '" "std::vector< cv::Matx< short,4,1 >::value_type,std::allocator< cv::Matx< short,4,1 >::value_type > >""'");
}
arg1 = *ptr;
if (SWIG_IsNewObj(res)) delete ptr;
}
result = (cv::Matx< short,4,1 > *)new_cv_Matx_Sl_short_Sc_4_Sc_1_Sg___SWIG_6(arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_short_4_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_short_4_1(PyObject *self, PyObject *args) {
Py_ssize_t argc;
PyObject *argv[4] = {
0
};
Py_ssize_t ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = args ? PyObject_Length(args) : 0;
for (ii = 0; (ii < 3) && (ii < argc); 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_short, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_short_4_1__SWIG_0(self, args);
}
}
if (argc == 1) {
int _v;
int res = swig::asptr(argv[0], (std::vector< short,std::allocator< short > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_short_4_1__SWIG_6(self, args);
}
}
if (argc == 2) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_short_1_4_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__Matx_TOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_short_4_1__SWIG_5(self, args);
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_short_4_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_short_4_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_MulOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_short_4_1__SWIG_3(self, args);
}
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_short_4_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_short_4_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_DivOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_short_4_1__SWIG_4(self, args);
}
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_short_4_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_short_4_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_AddOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_short_4_1__SWIG_1(self, args);
}
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_short_4_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_short_4_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_SubOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_short_4_1__SWIG_2(self, args);
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new__Matx_short_4_1'.\n"
" Possible C/C++ prototypes are:\n"
" cv::Matx< short,4,1 >::Matx(short const *)\n"
" cv::Matx< short,4,1 >::Matx(cv::Matx< short,4,1 > const &,cv::Matx< short,4,1 > const &,cv::Matx_AddOp)\n"
" cv::Matx< short,4,1 >::Matx(cv::Matx< short,4,1 > const &,cv::Matx< short,4,1 > const &,cv::Matx_SubOp)\n"
" cv::Matx< short,4,1 >::Matx(cv::Matx< short,4,1 > const &,cv::Matx< short,4,1 > const &,cv::Matx_MulOp)\n"
" cv::Matx< short,4,1 >::Matx(cv::Matx< short,4,1 > const &,cv::Matx< short,4,1 > const &,cv::Matx_DivOp)\n"
" cv::Matx< short,4,1 >::Matx(cv::Matx< short,1,4 > const &,cv::Matx_TOp)\n"
" cv::Matx< short,4,1 >::Matx(std::vector< cv::Matx< short,4,1 >::value_type,std::allocator< cv::Matx< short,4,1 >::value_type > >)\n");
return 0;
}
SWIGINTERN PyObject *_wrap__Matx_short_4_1___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< short,4,1 > *arg1 = (cv::Matx< short,4,1 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
std::string result;
if (!PyArg_ParseTuple(args,(char *)"O:_Matx_short_4_1___str__",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_short_4_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_short_4_1___str__" "', argument " "1"" of type '" "cv::Matx< short,4,1 > *""'");
}
arg1 = reinterpret_cast< cv::Matx< short,4,1 > * >(argp1);
result = cv_Matx_Sl_short_Sc_4_Sc_1_Sg____str__(arg1);
resultobj = SWIG_From_std_string(static_cast< std::string >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete__Matx_short_4_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< short,4,1 > *arg1 = (cv::Matx< short,4,1 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete__Matx_short_4_1",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_short_4_1_t, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__Matx_short_4_1" "', argument " "1"" of type '" "cv::Matx< short,4,1 > *""'");
}
arg1 = reinterpret_cast< cv::Matx< short,4,1 > * >(argp1);
delete arg1;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_Matx_short_4_1_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_cv__MatxT_short_4_1_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_new__Vec_short_4__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
short *arg1 = (short *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
cv::Vec< short,4 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__Vec_short_4",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_short, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Vec_short_4" "', argument " "1"" of type '" "short const *""'");
}
arg1 = reinterpret_cast< short * >(argp1);
result = (cv::Vec< short,4 > *)new cv::Vec< short,4 >((short const *)arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__VecT_short_4_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Vec_short_4__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Vec< short,4 > *arg1 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
cv::Vec< short,4 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__Vec_short_4",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__VecT_short_4_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Vec_short_4" "', argument " "1"" of type '" "cv::Vec< short,4 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_short_4" "', argument " "1"" of type '" "cv::Vec< short,4 > const &""'");
}
arg1 = reinterpret_cast< cv::Vec< short,4 > * >(argp1);
result = (cv::Vec< short,4 > *)new cv::Vec< short,4 >((cv::Vec< short,4 > const &)*arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__VecT_short_4_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Vec_short_4_all(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
short arg1 ;
short val1 ;
int ecode1 = 0 ;
PyObject * obj0 = 0 ;
SwigValueWrapper< cv::Vec< short,4 > > result;
if (!PyArg_ParseTuple(args,(char *)"O:_Vec_short_4_all",&obj0)) SWIG_fail;
ecode1 = SWIG_AsVal_short(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_Vec_short_4_all" "', argument " "1"" of type '" "short""'");
}
arg1 = static_cast< short >(val1);
result = cv::Vec< short,4 >::SWIGTEMPLATEDISAMBIGUATOR all(arg1);
resultobj = SWIG_NewPointerObj((new cv::Vec< short,4 >(static_cast< const cv::Vec< short,4 >& >(result))), SWIGTYPE_p_cv__VecT_short_4_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Vec_short_4_mul(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Vec< short,4 > *arg1 = (cv::Vec< short,4 > *) 0 ;
cv::Vec< short,4 > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
SwigValueWrapper< cv::Vec< short,4 > > result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Vec_short_4_mul",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__VecT_short_4_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Vec_short_4_mul" "', argument " "1"" of type '" "cv::Vec< short,4 > const *""'");
}
arg1 = reinterpret_cast< cv::Vec< short,4 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__VecT_short_4_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Vec_short_4_mul" "', argument " "2"" of type '" "cv::Vec< short,4 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Vec_short_4_mul" "', argument " "2"" of type '" "cv::Vec< short,4 > const &""'");
}
arg2 = reinterpret_cast< cv::Vec< short,4 > * >(argp2);
result = ((cv::Vec< short,4 > const *)arg1)->mul((cv::Vec< short,4 > const &)*arg2);
resultobj = SWIG_NewPointerObj((new cv::Vec< short,4 >(static_cast< const cv::Vec< short,4 >& >(result))), SWIGTYPE_p_cv__VecT_short_4_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Vec_short_4___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Vec< short,4 > *arg1 = (cv::Vec< short,4 > *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
short *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:_Vec_short_4___call__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__VecT_short_4_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Vec_short_4___call__" "', argument " "1"" of type '" "cv::Vec< short,4 > const *""'");
}
arg1 = reinterpret_cast< cv::Vec< short,4 > * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_Vec_short_4___call__" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
result = (short *) &((cv::Vec< short,4 > const *)arg1)->operator ()(arg2);
resultobj = SWIG_From_short(static_cast< short >(*result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Vec_short_4__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< short,4,1 > *arg1 = 0 ;
cv::Matx< short,4,1 > *arg2 = 0 ;
cv::Matx_AddOp 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 ;
cv::Vec< short,4 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Vec_short_4",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_short_4_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Vec_short_4" "', argument " "1"" of type '" "cv::Matx< short,4,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_short_4" "', argument " "1"" of type '" "cv::Matx< short,4,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< short,4,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_short_4_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Vec_short_4" "', argument " "2"" of type '" "cv::Matx< short,4,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_short_4" "', argument " "2"" of type '" "cv::Matx< short,4,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< short,4,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_AddOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Vec_short_4" "', argument " "3"" of type '" "cv::Matx_AddOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_short_4" "', argument " "3"" of type '" "cv::Matx_AddOp""'");
} else {
cv::Matx_AddOp * temp = reinterpret_cast< cv::Matx_AddOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Vec< short,4 > *)new cv::Vec< short,4 >((cv::Matx< short,4,1 > const &)*arg1,(cv::Matx< short,4,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__VecT_short_4_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Vec_short_4__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< short,4,1 > *arg1 = 0 ;
cv::Matx< short,4,1 > *arg2 = 0 ;
cv::Matx_SubOp 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 ;
cv::Vec< short,4 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Vec_short_4",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_short_4_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Vec_short_4" "', argument " "1"" of type '" "cv::Matx< short,4,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_short_4" "', argument " "1"" of type '" "cv::Matx< short,4,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< short,4,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_short_4_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Vec_short_4" "', argument " "2"" of type '" "cv::Matx< short,4,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_short_4" "', argument " "2"" of type '" "cv::Matx< short,4,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< short,4,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_SubOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Vec_short_4" "', argument " "3"" of type '" "cv::Matx_SubOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_short_4" "', argument " "3"" of type '" "cv::Matx_SubOp""'");
} else {
cv::Matx_SubOp * temp = reinterpret_cast< cv::Matx_SubOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Vec< short,4 > *)new cv::Vec< short,4 >((cv::Matx< short,4,1 > const &)*arg1,(cv::Matx< short,4,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__VecT_short_4_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Vec_short_4__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< cv::Vec< short,4 >::value_type,std::allocator< cv::Vec< short,4 >::value_type > > arg1 ;
PyObject * obj0 = 0 ;
cv::Vec< short,4 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__Vec_short_4",&obj0)) SWIG_fail;
{
std::vector< short,std::allocator< short > > *ptr = (std::vector< short,std::allocator< short > > *)0;
int res = swig::asptr(obj0, &ptr);
if (!SWIG_IsOK(res) || !ptr) {
SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new__Vec_short_4" "', argument " "1"" of type '" "std::vector< cv::Vec< short,4 >::value_type,std::allocator< cv::Vec< short,4 >::value_type > >""'");
}
arg1 = *ptr;
if (SWIG_IsNewObj(res)) delete ptr;
}
result = (cv::Vec< short,4 > *)new_cv_Vec_Sl_short_Sc_4_Sg___SWIG_4(arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__VecT_short_4_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Vec_short_4(PyObject *self, PyObject *args) {
Py_ssize_t argc;
PyObject *argv[4] = {
0
};
Py_ssize_t ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = args ? PyObject_Length(args) : 0;
for (ii = 0; (ii < 3) && (ii < argc); 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_short, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Vec_short_4__SWIG_0(self, args);
}
}
if (argc == 1) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__VecT_short_4_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Vec_short_4__SWIG_1(self, args);
}
}
if (argc == 1) {
int _v;
int res = swig::asptr(argv[0], (std::vector< short,std::allocator< short > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Vec_short_4__SWIG_4(self, args);
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_short_4_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_short_4_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_SubOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Vec_short_4__SWIG_3(self, args);
}
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_short_4_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_short_4_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_AddOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Vec_short_4__SWIG_2(self, args);
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new__Vec_short_4'.\n"
" Possible C/C++ prototypes are:\n"
" cv::Vec< short,4 >::Vec(short const *)\n"
" cv::Vec< short,4 >::Vec(cv::Vec< short,4 > const &)\n"
" cv::Vec< short,4 >::Vec(cv::Matx< short,4,1 > const &,cv::Matx< short,4,1 > const &,cv::Matx_AddOp)\n"
" cv::Vec< short,4 >::Vec(cv::Matx< short,4,1 > const &,cv::Matx< short,4,1 > const &,cv::Matx_SubOp)\n"
" cv::Vec< short,4 >::Vec(std::vector< cv::Vec< short,4 >::value_type,std::allocator< cv::Vec< short,4 >::value_type > >)\n");
return 0;
}
SWIGINTERN PyObject *_wrap__Vec_short_4___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Vec< short,4 > *arg1 = (cv::Vec< short,4 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
std::string result;
if (!PyArg_ParseTuple(args,(char *)"O:_Vec_short_4___str__",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__VecT_short_4_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Vec_short_4___str__" "', argument " "1"" of type '" "cv::Vec< short,4 > *""'");
}
arg1 = reinterpret_cast< cv::Vec< short,4 > * >(argp1);
result = cv_Vec_Sl_short_Sc_4_Sg____str__(arg1);
resultobj = SWIG_From_std_string(static_cast< std::string >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete__Vec_short_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Vec< short,4 > *arg1 = (cv::Vec< short,4 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete__Vec_short_4",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__VecT_short_4_t, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__Vec_short_4" "', argument " "1"" of type '" "cv::Vec< short,4 > *""'");
}
arg1 = reinterpret_cast< cv::Vec< short,4 > * >(argp1);
delete arg1;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_Vec_short_4_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_cv__VecT_short_4_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_new__DataType_Vec_short_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::DataType< cv::Vec< short,4 > > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new__DataType_Vec_short_4")) SWIG_fail;
result = (cv::DataType< cv::Vec< short,4 > > *)new cv::DataType< cv::Vec< short,4 > >();
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__DataTypeT_cv__VecT_short_4_t_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete__DataType_Vec_short_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::DataType< cv::Vec< short,4 > > *arg1 = (cv::DataType< cv::Vec< short,4 > > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete__DataType_Vec_short_4",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__DataTypeT_cv__VecT_short_4_t_t, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__DataType_Vec_short_4" "', argument " "1"" of type '" "cv::DataType< cv::Vec< short,4 > > *""'");
}
arg1 = reinterpret_cast< cv::DataType< cv::Vec< short,4 > > * >(argp1);
delete arg1;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_DataType_Vec_short_4_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_cv__DataTypeT_cv__VecT_short_4_t_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_new__cv_numpy_sizeof_ushort(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::_SizeOf< ushort > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new__cv_numpy_sizeof_ushort")) SWIG_fail;
result = (cv::_SizeOf< ushort > *)new cv::_SizeOf< ushort >();
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv___SizeOfT_ushort_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete__cv_numpy_sizeof_ushort(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::_SizeOf< ushort > *arg1 = (cv::_SizeOf< ushort > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete__cv_numpy_sizeof_ushort",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv___SizeOfT_ushort_t, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__cv_numpy_sizeof_ushort" "', argument " "1"" of type '" "cv::_SizeOf< ushort > *""'");
}
arg1 = reinterpret_cast< cv::_SizeOf< ushort > * >(argp1);
delete arg1;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_cv_numpy_sizeof_ushort_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_cv___SizeOfT_ushort_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap__ushortArray_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< ushort > *arg1 = (std::vector< ushort > *) 0 ;
PyObject **arg2 = (PyObject **) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
swig::SwigPyIterator *result = 0 ;
arg2 = &obj0;
if (!PyArg_ParseTuple(args,(char *)"O:_ushortArray_iterator",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_ushort_std__allocatorT_ushort_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_ushortArray_iterator" "', argument " "1"" of type '" "std::vector< ushort > *""'");
}
arg1 = reinterpret_cast< std::vector< ushort > * >(argp1);
result = (swig::SwigPyIterator *)std_vector_Sl_ushort_Sg__iterator(arg1,arg2);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__ushortArray___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< ushort > *arg1 = (std::vector< ushort > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
bool result;
if (!PyArg_ParseTuple(args,(char *)"O:_ushortArray___nonzero__",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_ushort_std__allocatorT_ushort_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_ushortArray___nonzero__" "', argument " "1"" of type '" "std::vector< ushort > const *""'");
}
arg1 = reinterpret_cast< std::vector< ushort > * >(argp1);
result = (bool)std_vector_Sl_ushort_Sg____nonzero__((std::vector< ushort > const *)arg1);
resultobj = SWIG_From_bool(static_cast< bool >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__ushortArray___bool__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< ushort > *arg1 = (std::vector< ushort > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
bool result;
if (!PyArg_ParseTuple(args,(char *)"O:_ushortArray___bool__",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_ushort_std__allocatorT_ushort_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_ushortArray___bool__" "', argument " "1"" of type '" "std::vector< ushort > const *""'");
}
arg1 = reinterpret_cast< std::vector< ushort > * >(argp1);
result = (bool)std_vector_Sl_ushort_Sg____bool__((std::vector< ushort > const *)arg1);
resultobj = SWIG_From_bool(static_cast< bool >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__ushortArray___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< ushort > *arg1 = (std::vector< ushort > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
std::vector< ushort >::size_type result;
if (!PyArg_ParseTuple(args,(char *)"O:_ushortArray___len__",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_ushort_std__allocatorT_ushort_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_ushortArray___len__" "', argument " "1"" of type '" "std::vector< ushort > const *""'");
}
arg1 = reinterpret_cast< std::vector< ushort > * >(argp1);
result = std_vector_Sl_ushort_Sg____len__((std::vector< ushort > const *)arg1);
resultobj = SWIG_From_size_t(static_cast< size_t >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__ushortArray___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< ushort > *arg1 = (std::vector< ushort > *) 0 ;
std::vector< ushort >::difference_type arg2 ;
std::vector< ushort >::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< ushort,std::allocator< ushort > > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:_ushortArray___getslice__",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_ushort_std__allocatorT_ushort_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_ushortArray___getslice__" "', argument " "1"" of type '" "std::vector< ushort > *""'");
}
arg1 = reinterpret_cast< std::vector< ushort > * >(argp1);
ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_ushortArray___getslice__" "', argument " "2"" of type '" "std::vector< ushort >::difference_type""'");
}
arg2 = static_cast< std::vector< ushort >::difference_type >(val2);
ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "_ushortArray___getslice__" "', argument " "3"" of type '" "std::vector< ushort >::difference_type""'");
}
arg3 = static_cast< std::vector< ushort >::difference_type >(val3);
try {
result = (std::vector< ushort,std::allocator< ushort > > *)std_vector_Sl_ushort_Sg____getslice__(arg1,arg2,arg3);
}
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_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ushort_std__allocatorT_ushort_t_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__ushortArray___setslice____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< ushort > *arg1 = (std::vector< ushort > *) 0 ;
std::vector< ushort >::difference_type arg2 ;
std::vector< ushort >::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:_ushortArray___setslice__",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_ushort_std__allocatorT_ushort_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_ushortArray___setslice__" "', argument " "1"" of type '" "std::vector< ushort > *""'");
}
arg1 = reinterpret_cast< std::vector< ushort > * >(argp1);
ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_ushortArray___setslice__" "', argument " "2"" of type '" "std::vector< ushort >::difference_type""'");
}
arg2 = static_cast< std::vector< ushort >::difference_type >(val2);
ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "_ushortArray___setslice__" "', argument " "3"" of type '" "std::vector< ushort >::difference_type""'");
}
arg3 = static_cast< std::vector< ushort >::difference_type >(val3);
try {
std_vector_Sl_ushort_Sg____setslice____SWIG_0(arg1,arg2,arg3);
}
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();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__ushortArray___setslice____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< ushort > *arg1 = (std::vector< ushort > *) 0 ;
std::vector< ushort >::difference_type arg2 ;
std::vector< ushort >::difference_type arg3 ;
std::vector< ushort,std::allocator< ushort > > *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:_ushortArray___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_ushort_std__allocatorT_ushort_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_ushortArray___setslice__" "', argument " "1"" of type '" "std::vector< ushort > *""'");
}
arg1 = reinterpret_cast< std::vector< ushort > * >(argp1);
ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_ushortArray___setslice__" "', argument " "2"" of type '" "std::vector< ushort >::difference_type""'");
}
arg2 = static_cast< std::vector< ushort >::difference_type >(val2);
ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "_ushortArray___setslice__" "', argument " "3"" of type '" "std::vector< ushort >::difference_type""'");
}
arg3 = static_cast< std::vector< ushort >::difference_type >(val3);
{
std::vector< ushort,std::allocator< ushort > > *ptr = (std::vector< ushort,std::allocator< ushort > > *)0;
res4 = swig::asptr(obj3, &ptr);
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "_ushortArray___setslice__" "', argument " "4"" of type '" "std::vector< ushort,std::allocator< ushort > > const &""'");
}
if (!ptr) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_ushortArray___setslice__" "', argument " "4"" of type '" "std::vector< ushort,std::allocator< ushort > > const &""'");
}
arg4 = ptr;
}
try {
std_vector_Sl_ushort_Sg____setslice____SWIG_1(arg1,arg2,arg3,(std::vector< ushort,std::allocator< ushort > > 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__ushortArray___setslice__(PyObject *self, PyObject *args) {
Py_ssize_t argc;
PyObject *argv[5] = {
0
};
Py_ssize_t ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = args ? PyObject_Length(args) : 0;
for (ii = 0; (ii < 4) && (ii < argc); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 3) {
int _v;
int res = swig::asptr(argv[0], (std::vector< ushort,std::allocator< ushort > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap__ushortArray___setslice____SWIG_0(self, args);
}
}
}
}
if (argc == 4) {
int _v;
int res = swig::asptr(argv[0], (std::vector< ushort,std::allocator< ushort > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
int res = swig::asptr(argv[3], (std::vector< ushort,std::allocator< ushort > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
return _wrap__ushortArray___setslice____SWIG_1(self, args);
}
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function '_ushortArray___setslice__'.\n"
" Possible C/C++ prototypes are:\n"
" std::vector< ushort >::__setslice__(std::vector< ushort >::difference_type,std::vector< ushort >::difference_type)\n"
" std::vector< ushort >::__setslice__(std::vector< ushort >::difference_type,std::vector< ushort >::difference_type,std::vector< ushort,std::allocator< ushort > > const &)\n");
return 0;
}
SWIGINTERN PyObject *_wrap__ushortArray___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< ushort > *arg1 = (std::vector< ushort > *) 0 ;
std::vector< ushort >::difference_type arg2 ;
std::vector< ushort >::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:_ushortArray___delslice__",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_ushort_std__allocatorT_ushort_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_ushortArray___delslice__" "', argument " "1"" of type '" "std::vector< ushort > *""'");
}
arg1 = reinterpret_cast< std::vector< ushort > * >(argp1);
ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_ushortArray___delslice__" "', argument " "2"" of type '" "std::vector< ushort >::difference_type""'");
}
arg2 = static_cast< std::vector< ushort >::difference_type >(val2);
ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "_ushortArray___delslice__" "', argument " "3"" of type '" "std::vector< ushort >::difference_type""'");
}
arg3 = static_cast< std::vector< ushort >::difference_type >(val3);
try {
std_vector_Sl_ushort_Sg____delslice__(arg1,arg2,arg3);
}
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();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__ushortArray___delitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< ushort > *arg1 = (std::vector< ushort > *) 0 ;
std::vector< ushort >::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:_ushortArray___delitem__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_ushort_std__allocatorT_ushort_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_ushortArray___delitem__" "', argument " "1"" of type '" "std::vector< ushort > *""'");
}
arg1 = reinterpret_cast< std::vector< ushort > * >(argp1);
ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_ushortArray___delitem__" "', argument " "2"" of type '" "std::vector< ushort >::difference_type""'");
}
arg2 = static_cast< std::vector< ushort >::difference_type >(val2);
try {
std_vector_Sl_ushort_Sg____delitem____SWIG_0(arg1,arg2);
}
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();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__ushortArray___getitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< ushort > *arg1 = (std::vector< ushort > *) 0 ;
PySliceObject *arg2 = (PySliceObject *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
std::vector< ushort,std::allocator< ushort > > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:_ushortArray___getitem__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_ushort_std__allocatorT_ushort_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_ushortArray___getitem__" "', argument " "1"" of type '" "std::vector< ushort > *""'");
}
arg1 = reinterpret_cast< std::vector< ushort > * >(argp1);
{
if (!PySlice_Check(obj1)) {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "_ushortArray___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
arg2 = (PySliceObject *) obj1;
}
try {
result = (std::vector< ushort,std::allocator< ushort > > *)std_vector_Sl_ushort_Sg____getitem____SWIG_0(arg1,arg2);
}
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_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ushort_std__allocatorT_ushort_t_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__ushortArray___setitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< ushort > *arg1 = (std::vector< ushort > *) 0 ;
PySliceObject *arg2 = (PySliceObject *) 0 ;
std::vector< ushort,std::allocator< ushort > > *arg3 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res3 = SWIG_OLDOBJ ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:_ushortArray___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_ushort_std__allocatorT_ushort_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_ushortArray___setitem__" "', argument " "1"" of type '" "std::vector< ushort > *""'");
}
arg1 = reinterpret_cast< std::vector< ushort > * >(argp1);
{
if (!PySlice_Check(obj1)) {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "_ushortArray___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
arg2 = (PySliceObject *) obj1;
}
{
std::vector< ushort,std::allocator< ushort > > *ptr = (std::vector< ushort,std::allocator< ushort > > *)0;
res3 = swig::asptr(obj2, &ptr);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "_ushortArray___setitem__" "', argument " "3"" of type '" "std::vector< ushort,std::allocator< ushort > > const &""'");
}
if (!ptr) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_ushortArray___setitem__" "', argument " "3"" of type '" "std::vector< ushort,std::allocator< ushort > > const &""'");
}
arg3 = ptr;
}
try {
std_vector_Sl_ushort_Sg____setitem____SWIG_0(arg1,arg2,(std::vector< ushort,std::allocator< ushort > > const &)*arg3);
}
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(res3)) delete arg3;
return resultobj;
fail:
if (SWIG_IsNewObj(res3)) delete arg3;
return NULL;
}
SWIGINTERN PyObject *_wrap__ushortArray___setitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< ushort > *arg1 = (std::vector< ushort > *) 0 ;
PySliceObject *arg2 = (PySliceObject *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:_ushortArray___setitem__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_ushort_std__allocatorT_ushort_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_ushortArray___setitem__" "', argument " "1"" of type '" "std::vector< ushort > *""'");
}
arg1 = reinterpret_cast< std::vector< ushort > * >(argp1);
{
if (!PySlice_Check(obj1)) {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "_ushortArray___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
arg2 = (PySliceObject *) obj1;
}
try {
std_vector_Sl_ushort_Sg____setitem____SWIG_1(arg1,arg2);
}
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();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__ushortArray___delitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< ushort > *arg1 = (std::vector< ushort > *) 0 ;
PySliceObject *arg2 = (PySliceObject *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:_ushortArray___delitem__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_ushort_std__allocatorT_ushort_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_ushortArray___delitem__" "', argument " "1"" of type '" "std::vector< ushort > *""'");
}
arg1 = reinterpret_cast< std::vector< ushort > * >(argp1);
{
if (!PySlice_Check(obj1)) {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "_ushortArray___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
arg2 = (PySliceObject *) obj1;
}
try {
std_vector_Sl_ushort_Sg____delitem____SWIG_1(arg1,arg2);
}
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();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__ushortArray___delitem__(PyObject *self, PyObject *args) {
Py_ssize_t argc;
PyObject *argv[3] = {
0
};
Py_ssize_t ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = args ? PyObject_Length(args) : 0;
for (ii = 0; (ii < 2) && (ii < argc); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 2) {
int _v;
int res = swig::asptr(argv[0], (std::vector< ushort,std::allocator< ushort > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
{
_v = PySlice_Check(argv[1]);
}
if (_v) {
return _wrap__ushortArray___delitem____SWIG_1(self, args);
}
}
}
if (argc == 2) {
int _v;
int res = swig::asptr(argv[0], (std::vector< ushort,std::allocator< ushort > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap__ushortArray___delitem____SWIG_0(self, args);
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function '_ushortArray___delitem__'.\n"
" Possible C/C++ prototypes are:\n"
" std::vector< ushort >::__delitem__(std::vector< ushort >::difference_type)\n"
" std::vector< ushort >::__delitem__(PySliceObject *)\n");
return 0;
}
SWIGINTERN PyObject *_wrap__ushortArray___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< ushort > *arg1 = (std::vector< ushort > *) 0 ;
std::vector< ushort >::difference_type arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
ptrdiff_t val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
std::vector< ushort >::value_type *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:_ushortArray___getitem__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_ushort_std__allocatorT_ushort_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_ushortArray___getitem__" "', argument " "1"" of type '" "std::vector< ushort > const *""'");
}
arg1 = reinterpret_cast< std::vector< ushort > * >(argp1);
ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_ushortArray___getitem__" "', argument " "2"" of type '" "std::vector< ushort >::difference_type""'");
}
arg2 = static_cast< std::vector< ushort >::difference_type >(val2);
try {
result = (std::vector< ushort >::value_type *) &std_vector_Sl_ushort_Sg____getitem____SWIG_1((std::vector< ushort > const *)arg1,arg2);
}
catch(std::out_of_range &_e) {
SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ushort, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__ushortArray___getitem__(PyObject *self, PyObject *args) {
Py_ssize_t argc;
PyObject *argv[3] = {
0
};
Py_ssize_t ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = args ? PyObject_Length(args) : 0;
for (ii = 0; (ii < 2) && (ii < argc); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 2) {
int _v;
int res = swig::asptr(argv[0], (std::vector< ushort,std::allocator< ushort > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
{
_v = PySlice_Check(argv[1]);
}
if (_v) {
return _wrap__ushortArray___getitem____SWIG_0(self, args);
}
}
}
if (argc == 2) {
int _v;
int res = swig::asptr(argv[0], (std::vector< ushort,std::allocator< ushort > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap__ushortArray___getitem____SWIG_1(self, args);
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function '_ushortArray___getitem__'.\n"
" Possible C/C++ prototypes are:\n"
" std::vector< ushort >::__getitem__(PySliceObject *)\n"
" std::vector< ushort >::__getitem__(std::vector< ushort >::difference_type) const\n");
return 0;
}
SWIGINTERN PyObject *_wrap__ushortArray___setitem____SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< ushort > *arg1 = (std::vector< ushort > *) 0 ;
std::vector< ushort >::difference_type arg2 ;
std::vector< ushort >::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:_ushortArray___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_ushort_std__allocatorT_ushort_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_ushortArray___setitem__" "', argument " "1"" of type '" "std::vector< ushort > *""'");
}
arg1 = reinterpret_cast< std::vector< ushort > * >(argp1);
ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_ushortArray___setitem__" "', argument " "2"" of type '" "std::vector< ushort >::difference_type""'");
}
arg2 = static_cast< std::vector< ushort >::difference_type >(val2);
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_ushort, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "_ushortArray___setitem__" "', argument " "3"" of type '" "std::vector< ushort >::value_type const &""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_ushortArray___setitem__" "', argument " "3"" of type '" "std::vector< ushort >::value_type const &""'");
}
arg3 = reinterpret_cast< std::vector< ushort >::value_type * >(argp3);
try {
std_vector_Sl_ushort_Sg____setitem____SWIG_2(arg1,arg2,(ushort 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__ushortArray___setitem__(PyObject *self, PyObject *args) {
Py_ssize_t argc;
PyObject *argv[4] = {
0
};
Py_ssize_t ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = args ? PyObject_Length(args) : 0;
for (ii = 0; (ii < 3) && (ii < argc); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 2) {
int _v;
int res = swig::asptr(argv[0], (std::vector< ushort,std::allocator< ushort > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
{
_v = PySlice_Check(argv[1]);
}
if (_v) {
return _wrap__ushortArray___setitem____SWIG_1(self, args);
}
}
}
if (argc == 3) {
int _v;
int res = swig::asptr(argv[0], (std::vector< ushort,std::allocator< ushort > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
{
_v = PySlice_Check(argv[1]);
}
if (_v) {
int res = swig::asptr(argv[2], (std::vector< ushort,std::allocator< ushort > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
return _wrap__ushortArray___setitem____SWIG_0(self, args);
}
}
}
}
if (argc == 3) {
int _v;
int res = swig::asptr(argv[0], (std::vector< ushort,std::allocator< ushort > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ushort, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap__ushortArray___setitem____SWIG_2(self, args);
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function '_ushortArray___setitem__'.\n"
" Possible C/C++ prototypes are:\n"
" std::vector< ushort >::__setitem__(PySliceObject *,std::vector< ushort,std::allocator< ushort > > const &)\n"
" std::vector< ushort >::__setitem__(PySliceObject *)\n"
" std::vector< ushort >::__setitem__(std::vector< ushort >::difference_type,std::vector< ushort >::value_type const &)\n");
return 0;
}
SWIGINTERN PyObject *_wrap__ushortArray_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< ushort > *arg1 = (std::vector< ushort > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
std::vector< ushort >::value_type result;
if (!PyArg_ParseTuple(args,(char *)"O:_ushortArray_pop",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_ushort_std__allocatorT_ushort_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_ushortArray_pop" "', argument " "1"" of type '" "std::vector< ushort > *""'");
}
arg1 = reinterpret_cast< std::vector< ushort > * >(argp1);
try {
result = std_vector_Sl_ushort_Sg__pop(arg1);
}
catch(std::out_of_range &_e) {
SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
}
resultobj = SWIG_NewPointerObj((new std::vector< ushort >::value_type(static_cast< const std::vector< ushort >::value_type& >(result))), SWIGTYPE_p_ushort, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__ushortArray_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< ushort > *arg1 = (std::vector< ushort > *) 0 ;
std::vector< ushort >::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:_ushortArray_append",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_ushort_std__allocatorT_ushort_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_ushortArray_append" "', argument " "1"" of type '" "std::vector< ushort > *""'");
}
arg1 = reinterpret_cast< std::vector< ushort > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_ushort, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_ushortArray_append" "', argument " "2"" of type '" "std::vector< ushort >::value_type const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_ushortArray_append" "', argument " "2"" of type '" "std::vector< ushort >::value_type const &""'");
}
arg2 = reinterpret_cast< std::vector< ushort >::value_type * >(argp2);
std_vector_Sl_ushort_Sg__append(arg1,(ushort const &)*arg2);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__ushortArray__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< ushort > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new__ushortArray")) SWIG_fail;
result = (std::vector< ushort > *)new std::vector< ushort >();
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ushort_std__allocatorT_ushort_t_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__ushortArray__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< ushort > *arg1 = 0 ;
int res1 = SWIG_OLDOBJ ;
PyObject * obj0 = 0 ;
std::vector< ushort > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__ushortArray",&obj0)) SWIG_fail;
{
std::vector< ushort,std::allocator< ushort > > *ptr = (std::vector< ushort,std::allocator< ushort > > *)0;
res1 = swig::asptr(obj0, &ptr);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__ushortArray" "', argument " "1"" of type '" "std::vector< ushort > const &""'");
}
if (!ptr) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__ushortArray" "', argument " "1"" of type '" "std::vector< ushort > const &""'");
}
arg1 = ptr;
}
result = (std::vector< ushort > *)new std::vector< ushort >((std::vector< ushort > const &)*arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ushort_std__allocatorT_ushort_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__ushortArray_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< ushort > *arg1 = (std::vector< ushort > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
bool result;
if (!PyArg_ParseTuple(args,(char *)"O:_ushortArray_empty",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_ushort_std__allocatorT_ushort_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_ushortArray_empty" "', argument " "1"" of type '" "std::vector< ushort > const *""'");
}
arg1 = reinterpret_cast< std::vector< ushort > * >(argp1);
result = (bool)((std::vector< ushort > const *)arg1)->empty();
resultobj = SWIG_From_bool(static_cast< bool >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__ushortArray_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< ushort > *arg1 = (std::vector< ushort > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
std::vector< ushort >::size_type result;
if (!PyArg_ParseTuple(args,(char *)"O:_ushortArray_size",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_ushort_std__allocatorT_ushort_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_ushortArray_size" "', argument " "1"" of type '" "std::vector< ushort > const *""'");
}
arg1 = reinterpret_cast< std::vector< ushort > * >(argp1);
result = ((std::vector< ushort > const *)arg1)->size();
resultobj = SWIG_From_size_t(static_cast< size_t >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__ushortArray_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< ushort > *arg1 = (std::vector< ushort > *) 0 ;
std::vector< ushort > *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:_ushortArray_swap",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_ushort_std__allocatorT_ushort_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_ushortArray_swap" "', argument " "1"" of type '" "std::vector< ushort > *""'");
}
arg1 = reinterpret_cast< std::vector< ushort > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_ushort_std__allocatorT_ushort_t_t, 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_ushortArray_swap" "', argument " "2"" of type '" "std::vector< ushort > &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_ushortArray_swap" "', argument " "2"" of type '" "std::vector< ushort > &""'");
}
arg2 = reinterpret_cast< std::vector< ushort > * >(argp2);
(arg1)->swap(*arg2);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__ushortArray_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< ushort > *arg1 = (std::vector< ushort > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
std::vector< ushort >::iterator result;
if (!PyArg_ParseTuple(args,(char *)"O:_ushortArray_begin",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_ushort_std__allocatorT_ushort_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_ushortArray_begin" "', argument " "1"" of type '" "std::vector< ushort > *""'");
}
arg1 = reinterpret_cast< std::vector< ushort > * >(argp1);
result = (arg1)->begin();
resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ushort >::iterator & >(result)),
swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__ushortArray_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< ushort > *arg1 = (std::vector< ushort > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
std::vector< ushort >::iterator result;
if (!PyArg_ParseTuple(args,(char *)"O:_ushortArray_end",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_ushort_std__allocatorT_ushort_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_ushortArray_end" "', argument " "1"" of type '" "std::vector< ushort > *""'");
}
arg1 = reinterpret_cast< std::vector< ushort > * >(argp1);
result = (arg1)->end();
resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ushort >::iterator & >(result)),
swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__ushortArray_rbegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< ushort > *arg1 = (std::vector< ushort > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
std::vector< ushort >::reverse_iterator result;
if (!PyArg_ParseTuple(args,(char *)"O:_ushortArray_rbegin",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_ushort_std__allocatorT_ushort_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_ushortArray_rbegin" "', argument " "1"" of type '" "std::vector< ushort > *""'");
}
arg1 = reinterpret_cast< std::vector< ushort > * >(argp1);
result = (arg1)->rbegin();
resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ushort >::reverse_iterator & >(result)),
swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__ushortArray_rend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< ushort > *arg1 = (std::vector< ushort > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
std::vector< ushort >::reverse_iterator result;
if (!PyArg_ParseTuple(args,(char *)"O:_ushortArray_rend",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_ushort_std__allocatorT_ushort_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_ushortArray_rend" "', argument " "1"" of type '" "std::vector< ushort > *""'");
}
arg1 = reinterpret_cast< std::vector< ushort > * >(argp1);
result = (arg1)->rend();
resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ushort >::reverse_iterator & >(result)),
swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__ushortArray_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< ushort > *arg1 = (std::vector< ushort > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:_ushortArray_clear",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_ushort_std__allocatorT_ushort_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_ushortArray_clear" "', argument " "1"" of type '" "std::vector< ushort > *""'");
}
arg1 = reinterpret_cast< std::vector< ushort > * >(argp1);
(arg1)->clear();
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__ushortArray_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< ushort > *arg1 = (std::vector< ushort > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
SwigValueWrapper< std::allocator< ushort > > result;
if (!PyArg_ParseTuple(args,(char *)"O:_ushortArray_get_allocator",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_ushort_std__allocatorT_ushort_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_ushortArray_get_allocator" "', argument " "1"" of type '" "std::vector< ushort > const *""'");
}
arg1 = reinterpret_cast< std::vector< ushort > * >(argp1);
result = ((std::vector< ushort > const *)arg1)->get_allocator();
resultobj = SWIG_NewPointerObj((new std::vector< ushort >::allocator_type(static_cast< const std::vector< ushort >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_ushort_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__ushortArray__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< ushort >::size_type arg1 ;
size_t val1 ;
int ecode1 = 0 ;
PyObject * obj0 = 0 ;
std::vector< ushort > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__ushortArray",&obj0)) SWIG_fail;
ecode1 = SWIG_AsVal_size_t(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new__ushortArray" "', argument " "1"" of type '" "std::vector< ushort >::size_type""'");
}
arg1 = static_cast< std::vector< ushort >::size_type >(val1);
result = (std::vector< ushort > *)new std::vector< ushort >(arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ushort_std__allocatorT_ushort_t_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__ushortArray_pop_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< ushort > *arg1 = (std::vector< ushort > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:_ushortArray_pop_back",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_ushort_std__allocatorT_ushort_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_ushortArray_pop_back" "', argument " "1"" of type '" "std::vector< ushort > *""'");
}
arg1 = reinterpret_cast< std::vector< ushort > * >(argp1);
(arg1)->pop_back();
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__ushortArray_resize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< ushort > *arg1 = (std::vector< ushort > *) 0 ;
std::vector< ushort >::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:_ushortArray_resize",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_ushort_std__allocatorT_ushort_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_ushortArray_resize" "', argument " "1"" of type '" "std::vector< ushort > *""'");
}
arg1 = reinterpret_cast< std::vector< ushort > * >(argp1);
ecode2 = SWIG_AsVal_size_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_ushortArray_resize" "', argument " "2"" of type '" "std::vector< ushort >::size_type""'");
}
arg2 = static_cast< std::vector< ushort >::size_type >(val2);
(arg1)->resize(arg2);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__ushortArray_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< ushort > *arg1 = (std::vector< ushort > *) 0 ;
std::vector< ushort >::iterator arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
swig::SwigPyIterator *iter2 = 0 ;
int res2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
std::vector< ushort >::iterator result;
if (!PyArg_ParseTuple(args,(char *)"OO:_ushortArray_erase",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_ushort_std__allocatorT_ushort_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_ushortArray_erase" "', argument " "1"" of type '" "std::vector< ushort > *""'");
}
arg1 = reinterpret_cast< std::vector< ushort > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
if (!SWIG_IsOK(res2) || !iter2) {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "_ushortArray_erase" "', argument " "2"" of type '" "std::vector< ushort >::iterator""'");
} else {
swig::SwigPyIterator_T<std::vector< ushort >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< ushort >::iterator > *>(iter2);
if (iter_t) {
arg2 = iter_t->get_current();
} else {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "_ushortArray_erase" "', argument " "2"" of type '" "std::vector< ushort >::iterator""'");
}
}
result = std_vector_Sl_ushort_Sg__erase__SWIG_0(arg1,arg2);
resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ushort >::iterator & >(result)),
swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__ushortArray_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< ushort > *arg1 = (std::vector< ushort > *) 0 ;
std::vector< ushort >::iterator arg2 ;
std::vector< ushort >::iterator arg3 ;
void *argp1 = 0 ;
int res1 = 0 ;
swig::SwigPyIterator *iter2 = 0 ;
int res2 ;
swig::SwigPyIterator *iter3 = 0 ;
int res3 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
std::vector< ushort >::iterator result;
if (!PyArg_ParseTuple(args,(char *)"OOO:_ushortArray_erase",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_ushort_std__allocatorT_ushort_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_ushortArray_erase" "', argument " "1"" of type '" "std::vector< ushort > *""'");
}
arg1 = reinterpret_cast< std::vector< ushort > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
if (!SWIG_IsOK(res2) || !iter2) {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "_ushortArray_erase" "', argument " "2"" of type '" "std::vector< ushort >::iterator""'");
} else {
swig::SwigPyIterator_T<std::vector< ushort >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< ushort >::iterator > *>(iter2);
if (iter_t) {
arg2 = iter_t->get_current();
} else {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "_ushortArray_erase" "', argument " "2"" of type '" "std::vector< ushort >::iterator""'");
}
}
res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
if (!SWIG_IsOK(res3) || !iter3) {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "_ushortArray_erase" "', argument " "3"" of type '" "std::vector< ushort >::iterator""'");
} else {
swig::SwigPyIterator_T<std::vector< ushort >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< ushort >::iterator > *>(iter3);
if (iter_t) {
arg3 = iter_t->get_current();
} else {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "_ushortArray_erase" "', argument " "3"" of type '" "std::vector< ushort >::iterator""'");
}
}
result = std_vector_Sl_ushort_Sg__erase__SWIG_1(arg1,arg2,arg3);
resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ushort >::iterator & >(result)),
swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__ushortArray_erase(PyObject *self, PyObject *args) {
Py_ssize_t argc;
PyObject *argv[4] = {
0
};
Py_ssize_t ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = args ? PyObject_Length(args) : 0;
for (ii = 0; (ii < 3) && (ii < argc); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 2) {
int _v;
int res = swig::asptr(argv[0], (std::vector< ushort,std::allocator< ushort > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
swig::SwigPyIterator *iter = 0;
int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
_v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< ushort >::iterator > *>(iter) != 0));
if (_v) {
return _wrap__ushortArray_erase__SWIG_0(self, args);
}
}
}
if (argc == 3) {
int _v;
int res = swig::asptr(argv[0], (std::vector< ushort,std::allocator< ushort > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
swig::SwigPyIterator *iter = 0;
int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
_v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< ushort >::iterator > *>(iter) != 0));
if (_v) {
swig::SwigPyIterator *iter = 0;
int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
_v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< ushort >::iterator > *>(iter) != 0));
if (_v) {
return _wrap__ushortArray_erase__SWIG_1(self, args);
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function '_ushortArray_erase'.\n"
" Possible C/C++ prototypes are:\n"
" std::vector< ushort >::erase(std::vector< ushort >::iterator)\n"
" std::vector< ushort >::erase(std::vector< ushort >::iterator,std::vector< ushort >::iterator)\n");
return 0;
}
SWIGINTERN PyObject *_wrap_new__ushortArray__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< ushort >::size_type arg1 ;
std::vector< ushort >::value_type *arg2 = 0 ;
size_t val1 ;
int ecode1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
std::vector< ushort > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:new__ushortArray",&obj0,&obj1)) SWIG_fail;
ecode1 = SWIG_AsVal_size_t(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new__ushortArray" "', argument " "1"" of type '" "std::vector< ushort >::size_type""'");
}
arg1 = static_cast< std::vector< ushort >::size_type >(val1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_ushort, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__ushortArray" "', argument " "2"" of type '" "std::vector< ushort >::value_type const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__ushortArray" "', argument " "2"" of type '" "std::vector< ushort >::value_type const &""'");
}
arg2 = reinterpret_cast< std::vector< ushort >::value_type * >(argp2);
result = (std::vector< ushort > *)new std::vector< ushort >(arg1,(std::vector< ushort >::value_type const &)*arg2);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ushort_std__allocatorT_ushort_t_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__ushortArray(PyObject *self, PyObject *args) {
Py_ssize_t argc;
PyObject *argv[3] = {
0
};
Py_ssize_t ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = args ? PyObject_Length(args) : 0;
for (ii = 0; (ii < 2) && (ii < argc); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 0) {
return _wrap_new__ushortArray__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__ushortArray__SWIG_2(self, args);
}
}
if (argc == 1) {
int _v;
int res = swig::asptr(argv[0], (std::vector< ushort,std::allocator< ushort > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__ushortArray__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_ushort, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__ushortArray__SWIG_3(self, args);
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new__ushortArray'.\n"
" Possible C/C++ prototypes are:\n"
" std::vector< ushort >::vector()\n"
" std::vector< ushort >::vector(std::vector< ushort > const &)\n"
" std::vector< ushort >::vector(std::vector< ushort >::size_type)\n"
" std::vector< ushort >::vector(std::vector< ushort >::size_type,std::vector< ushort >::value_type const &)\n");
return 0;
}
SWIGINTERN PyObject *_wrap__ushortArray_push_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< ushort > *arg1 = (std::vector< ushort > *) 0 ;
std::vector< ushort >::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:_ushortArray_push_back",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_ushort_std__allocatorT_ushort_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_ushortArray_push_back" "', argument " "1"" of type '" "std::vector< ushort > *""'");
}
arg1 = reinterpret_cast< std::vector< ushort > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_ushort, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_ushortArray_push_back" "', argument " "2"" of type '" "std::vector< ushort >::value_type const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_ushortArray_push_back" "', argument " "2"" of type '" "std::vector< ushort >::value_type const &""'");
}
arg2 = reinterpret_cast< std::vector< ushort >::value_type * >(argp2);
(arg1)->push_back((std::vector< ushort >::value_type const &)*arg2);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__ushortArray_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< ushort > *arg1 = (std::vector< ushort > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
std::vector< ushort >::value_type *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:_ushortArray_front",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_ushort_std__allocatorT_ushort_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_ushortArray_front" "', argument " "1"" of type '" "std::vector< ushort > const *""'");
}
arg1 = reinterpret_cast< std::vector< ushort > * >(argp1);
result = (std::vector< ushort >::value_type *) &((std::vector< ushort > const *)arg1)->front();
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ushort, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__ushortArray_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< ushort > *arg1 = (std::vector< ushort > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
std::vector< ushort >::value_type *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:_ushortArray_back",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_ushort_std__allocatorT_ushort_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_ushortArray_back" "', argument " "1"" of type '" "std::vector< ushort > const *""'");
}
arg1 = reinterpret_cast< std::vector< ushort > * >(argp1);
result = (std::vector< ushort >::value_type *) &((std::vector< ushort > const *)arg1)->back();
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ushort, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__ushortArray_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< ushort > *arg1 = (std::vector< ushort > *) 0 ;
std::vector< ushort >::size_type arg2 ;
std::vector< ushort >::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:_ushortArray_assign",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_ushort_std__allocatorT_ushort_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_ushortArray_assign" "', argument " "1"" of type '" "std::vector< ushort > *""'");
}
arg1 = reinterpret_cast< std::vector< ushort > * >(argp1);
ecode2 = SWIG_AsVal_size_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_ushortArray_assign" "', argument " "2"" of type '" "std::vector< ushort >::size_type""'");
}
arg2 = static_cast< std::vector< ushort >::size_type >(val2);
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_ushort, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "_ushortArray_assign" "', argument " "3"" of type '" "std::vector< ushort >::value_type const &""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_ushortArray_assign" "', argument " "3"" of type '" "std::vector< ushort >::value_type const &""'");
}
arg3 = reinterpret_cast< std::vector< ushort >::value_type * >(argp3);
(arg1)->assign(arg2,(std::vector< ushort >::value_type const &)*arg3);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__ushortArray_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< ushort > *arg1 = (std::vector< ushort > *) 0 ;
std::vector< ushort >::size_type arg2 ;
std::vector< ushort >::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:_ushortArray_resize",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_ushort_std__allocatorT_ushort_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_ushortArray_resize" "', argument " "1"" of type '" "std::vector< ushort > *""'");
}
arg1 = reinterpret_cast< std::vector< ushort > * >(argp1);
ecode2 = SWIG_AsVal_size_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_ushortArray_resize" "', argument " "2"" of type '" "std::vector< ushort >::size_type""'");
}
arg2 = static_cast< std::vector< ushort >::size_type >(val2);
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_ushort, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "_ushortArray_resize" "', argument " "3"" of type '" "std::vector< ushort >::value_type const &""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_ushortArray_resize" "', argument " "3"" of type '" "std::vector< ushort >::value_type const &""'");
}
arg3 = reinterpret_cast< std::vector< ushort >::value_type * >(argp3);
(arg1)->resize(arg2,(std::vector< ushort >::value_type const &)*arg3);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__ushortArray_resize(PyObject *self, PyObject *args) {
Py_ssize_t argc;
PyObject *argv[4] = {
0
};
Py_ssize_t ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = args ? PyObject_Length(args) : 0;
for (ii = 0; (ii < 3) && (ii < argc); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 2) {
int _v;
int res = swig::asptr(argv[0], (std::vector< ushort,std::allocator< ushort > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_size_t(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap__ushortArray_resize__SWIG_0(self, args);
}
}
}
if (argc == 3) {
int _v;
int res = swig::asptr(argv[0], (std::vector< ushort,std::allocator< ushort > >**)(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_ushort, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap__ushortArray_resize__SWIG_1(self, args);
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function '_ushortArray_resize'.\n"
" Possible C/C++ prototypes are:\n"
" std::vector< ushort >::resize(std::vector< ushort >::size_type)\n"
" std::vector< ushort >::resize(std::vector< ushort >::size_type,std::vector< ushort >::value_type const &)\n");
return 0;
}
SWIGINTERN PyObject *_wrap__ushortArray_insert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< ushort > *arg1 = (std::vector< ushort > *) 0 ;
std::vector< ushort >::iterator arg2 ;
std::vector< ushort >::value_type *arg3 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
swig::SwigPyIterator *iter2 = 0 ;
int res2 ;
void *argp3 = 0 ;
int res3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
std::vector< ushort >::iterator result;
if (!PyArg_ParseTuple(args,(char *)"OOO:_ushortArray_insert",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_ushort_std__allocatorT_ushort_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_ushortArray_insert" "', argument " "1"" of type '" "std::vector< ushort > *""'");
}
arg1 = reinterpret_cast< std::vector< ushort > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
if (!SWIG_IsOK(res2) || !iter2) {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "_ushortArray_insert" "', argument " "2"" of type '" "std::vector< ushort >::iterator""'");
} else {
swig::SwigPyIterator_T<std::vector< ushort >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< ushort >::iterator > *>(iter2);
if (iter_t) {
arg2 = iter_t->get_current();
} else {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "_ushortArray_insert" "', argument " "2"" of type '" "std::vector< ushort >::iterator""'");
}
}
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_ushort, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "_ushortArray_insert" "', argument " "3"" of type '" "std::vector< ushort >::value_type const &""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_ushortArray_insert" "', argument " "3"" of type '" "std::vector< ushort >::value_type const &""'");
}
arg3 = reinterpret_cast< std::vector< ushort >::value_type * >(argp3);
result = std_vector_Sl_ushort_Sg__insert__SWIG_0(arg1,arg2,(ushort const &)*arg3);
resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ushort >::iterator & >(result)),
swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__ushortArray_insert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< ushort > *arg1 = (std::vector< ushort > *) 0 ;
std::vector< ushort >::iterator arg2 ;
std::vector< ushort >::size_type arg3 ;
std::vector< ushort >::value_type *arg4 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
swig::SwigPyIterator *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:_ushortArray_insert",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_ushort_std__allocatorT_ushort_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_ushortArray_insert" "', argument " "1"" of type '" "std::vector< ushort > *""'");
}
arg1 = reinterpret_cast< std::vector< ushort > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
if (!SWIG_IsOK(res2) || !iter2) {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "_ushortArray_insert" "', argument " "2"" of type '" "std::vector< ushort >::iterator""'");
} else {
swig::SwigPyIterator_T<std::vector< ushort >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< ushort >::iterator > *>(iter2);
if (iter_t) {
arg2 = iter_t->get_current();
} else {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "_ushortArray_insert" "', argument " "2"" of type '" "std::vector< ushort >::iterator""'");
}
}
ecode3 = SWIG_AsVal_size_t(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "_ushortArray_insert" "', argument " "3"" of type '" "std::vector< ushort >::size_type""'");
}
arg3 = static_cast< std::vector< ushort >::size_type >(val3);
res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_ushort, 0 | 0);
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "_ushortArray_insert" "', argument " "4"" of type '" "std::vector< ushort >::value_type const &""'");
}
if (!argp4) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_ushortArray_insert" "', argument " "4"" of type '" "std::vector< ushort >::value_type const &""'");
}
arg4 = reinterpret_cast< std::vector< ushort >::value_type * >(argp4);
std_vector_Sl_ushort_Sg__insert__SWIG_1(arg1,arg2,arg3,(ushort const &)*arg4);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__ushortArray_insert(PyObject *self, PyObject *args) {
Py_ssize_t argc;
PyObject *argv[5] = {
0
};
Py_ssize_t ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = args ? PyObject_Length(args) : 0;
for (ii = 0; (ii < 4) && (ii < argc); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 3) {
int _v;
int res = swig::asptr(argv[0], (std::vector< ushort,std::allocator< ushort > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
swig::SwigPyIterator *iter = 0;
int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
_v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< ushort >::iterator > *>(iter) != 0));
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ushort, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap__ushortArray_insert__SWIG_0(self, args);
}
}
}
}
if (argc == 4) {
int _v;
int res = swig::asptr(argv[0], (std::vector< ushort,std::allocator< ushort > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
swig::SwigPyIterator *iter = 0;
int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
_v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< ushort >::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_ushort, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap__ushortArray_insert__SWIG_1(self, args);
}
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function '_ushortArray_insert'.\n"
" Possible C/C++ prototypes are:\n"
" std::vector< ushort >::insert(std::vector< ushort >::iterator,std::vector< ushort >::value_type const &)\n"
" std::vector< ushort >::insert(std::vector< ushort >::iterator,std::vector< ushort >::size_type,std::vector< ushort >::value_type const &)\n");
return 0;
}
SWIGINTERN PyObject *_wrap__ushortArray_reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< ushort > *arg1 = (std::vector< ushort > *) 0 ;
std::vector< ushort >::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:_ushortArray_reserve",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_ushort_std__allocatorT_ushort_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_ushortArray_reserve" "', argument " "1"" of type '" "std::vector< ushort > *""'");
}
arg1 = reinterpret_cast< std::vector< ushort > * >(argp1);
ecode2 = SWIG_AsVal_size_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_ushortArray_reserve" "', argument " "2"" of type '" "std::vector< ushort >::size_type""'");
}
arg2 = static_cast< std::vector< ushort >::size_type >(val2);
(arg1)->reserve(arg2);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__ushortArray_capacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< ushort > *arg1 = (std::vector< ushort > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
std::vector< ushort >::size_type result;
if (!PyArg_ParseTuple(args,(char *)"O:_ushortArray_capacity",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_ushort_std__allocatorT_ushort_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_ushortArray_capacity" "', argument " "1"" of type '" "std::vector< ushort > const *""'");
}
arg1 = reinterpret_cast< std::vector< ushort > * >(argp1);
result = ((std::vector< ushort > const *)arg1)->capacity();
resultobj = SWIG_From_size_t(static_cast< size_t >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete__ushortArray(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< ushort > *arg1 = (std::vector< ushort > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete__ushortArray",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_ushort_std__allocatorT_ushort_t_t, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__ushortArray" "', argument " "1"" of type '" "std::vector< ushort > *""'");
}
arg1 = reinterpret_cast< std::vector< ushort > * >(argp1);
delete arg1;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_ushortArray_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_ushort_std__allocatorT_ushort_t_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_new__Matx_ushort_2_1__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
ushort *arg1 = (ushort *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
cv::Matx< ushort,2,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__Matx_ushort_2_1",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ushort, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_ushort_2_1" "', argument " "1"" of type '" "ushort const *""'");
}
arg1 = reinterpret_cast< ushort * >(argp1);
result = (cv::Matx< ushort,2,1 > *)new cv::Matx< ushort,2,1 >((ushort const *)arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_ushort_2_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_ushort_2_1_all(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
ushort arg1 ;
void *argp1 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
SwigValueWrapper< cv::Matx< ushort,2,1 > > result;
if (!PyArg_ParseTuple(args,(char *)"O:_Matx_ushort_2_1_all",&obj0)) SWIG_fail;
{
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_ushort, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_ushort_2_1_all" "', argument " "1"" of type '" "ushort""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Matx_ushort_2_1_all" "', argument " "1"" of type '" "ushort""'");
} else {
ushort * temp = reinterpret_cast< ushort * >(argp1);
arg1 = *temp;
if (SWIG_IsNewObj(res1)) delete temp;
}
}
result = cv::Matx< ushort,2,1 >::SWIGTEMPLATEDISAMBIGUATOR all(arg1);
resultobj = SWIG_NewPointerObj((new cv::Matx< ushort,2,1 >(static_cast< const cv::Matx< ushort,2,1 >& >(result))), SWIGTYPE_p_cv__MatxT_ushort_2_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_ushort_2_1_zeros(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
SwigValueWrapper< cv::Matx< ushort,2,1 > > result;
if (!PyArg_ParseTuple(args,(char *)":_Matx_ushort_2_1_zeros")) SWIG_fail;
result = cv::Matx< ushort,2,1 >::SWIGTEMPLATEDISAMBIGUATOR zeros();
resultobj = SWIG_NewPointerObj((new cv::Matx< ushort,2,1 >(static_cast< const cv::Matx< ushort,2,1 >& >(result))), SWIGTYPE_p_cv__MatxT_ushort_2_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_ushort_2_1_ones(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
SwigValueWrapper< cv::Matx< ushort,2,1 > > result;
if (!PyArg_ParseTuple(args,(char *)":_Matx_ushort_2_1_ones")) SWIG_fail;
result = cv::Matx< ushort,2,1 >::SWIGTEMPLATEDISAMBIGUATOR ones();
resultobj = SWIG_NewPointerObj((new cv::Matx< ushort,2,1 >(static_cast< const cv::Matx< ushort,2,1 >& >(result))), SWIGTYPE_p_cv__MatxT_ushort_2_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_ushort_2_1_eye(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
SwigValueWrapper< cv::Matx< ushort,2,1 > > result;
if (!PyArg_ParseTuple(args,(char *)":_Matx_ushort_2_1_eye")) SWIG_fail;
result = cv::Matx< ushort,2,1 >::SWIGTEMPLATEDISAMBIGUATOR eye();
resultobj = SWIG_NewPointerObj((new cv::Matx< ushort,2,1 >(static_cast< const cv::Matx< ushort,2,1 >& >(result))), SWIGTYPE_p_cv__MatxT_ushort_2_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_ushort_2_1_randu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
ushort arg1 ;
ushort arg2 ;
void *argp1 ;
int res1 = 0 ;
void *argp2 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
SwigValueWrapper< cv::Matx< ushort,2,1 > > result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_ushort_2_1_randu",&obj0,&obj1)) SWIG_fail;
{
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_ushort, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_ushort_2_1_randu" "', argument " "1"" of type '" "ushort""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Matx_ushort_2_1_randu" "', argument " "1"" of type '" "ushort""'");
} else {
ushort * temp = reinterpret_cast< ushort * >(argp1);
arg1 = *temp;
if (SWIG_IsNewObj(res1)) delete temp;
}
}
{
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_ushort, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_ushort_2_1_randu" "', argument " "2"" of type '" "ushort""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Matx_ushort_2_1_randu" "', argument " "2"" of type '" "ushort""'");
} else {
ushort * temp = reinterpret_cast< ushort * >(argp2);
arg2 = *temp;
if (SWIG_IsNewObj(res2)) delete temp;
}
}
result = cv::Matx< ushort,2,1 >::SWIGTEMPLATEDISAMBIGUATOR randu(arg1,arg2);
resultobj = SWIG_NewPointerObj((new cv::Matx< ushort,2,1 >(static_cast< const cv::Matx< ushort,2,1 >& >(result))), SWIGTYPE_p_cv__MatxT_ushort_2_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_ushort_2_1_randn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
ushort arg1 ;
ushort arg2 ;
void *argp1 ;
int res1 = 0 ;
void *argp2 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
SwigValueWrapper< cv::Matx< ushort,2,1 > > result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_ushort_2_1_randn",&obj0,&obj1)) SWIG_fail;
{
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_ushort, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_ushort_2_1_randn" "', argument " "1"" of type '" "ushort""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Matx_ushort_2_1_randn" "', argument " "1"" of type '" "ushort""'");
} else {
ushort * temp = reinterpret_cast< ushort * >(argp1);
arg1 = *temp;
if (SWIG_IsNewObj(res1)) delete temp;
}
}
{
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_ushort, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_ushort_2_1_randn" "', argument " "2"" of type '" "ushort""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Matx_ushort_2_1_randn" "', argument " "2"" of type '" "ushort""'");
} else {
ushort * temp = reinterpret_cast< ushort * >(argp2);
arg2 = *temp;
if (SWIG_IsNewObj(res2)) delete temp;
}
}
result = cv::Matx< ushort,2,1 >::SWIGTEMPLATEDISAMBIGUATOR randn(arg1,arg2);
resultobj = SWIG_NewPointerObj((new cv::Matx< ushort,2,1 >(static_cast< const cv::Matx< ushort,2,1 >& >(result))), SWIGTYPE_p_cv__MatxT_ushort_2_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_ushort_2_1_dot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< ushort,2,1 > *arg1 = (cv::Matx< ushort,2,1 > *) 0 ;
cv::Matx< ushort,2,1 > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
ushort result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_ushort_2_1_dot",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_ushort_2_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_ushort_2_1_dot" "', argument " "1"" of type '" "cv::Matx< ushort,2,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< ushort,2,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_ushort_2_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_ushort_2_1_dot" "', argument " "2"" of type '" "cv::Matx< ushort,2,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Matx_ushort_2_1_dot" "', argument " "2"" of type '" "cv::Matx< ushort,2,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< ushort,2,1 > * >(argp2);
result = ((cv::Matx< ushort,2,1 > const *)arg1)->dot((cv::Matx< ushort,2,1 > const &)*arg2);
resultobj = SWIG_NewPointerObj((new ushort(static_cast< const ushort& >(result))), SWIGTYPE_p_ushort, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_ushort_2_1_ddot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< ushort,2,1 > *arg1 = (cv::Matx< ushort,2,1 > *) 0 ;
cv::Matx< ushort,2,1 > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
double result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_ushort_2_1_ddot",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_ushort_2_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_ushort_2_1_ddot" "', argument " "1"" of type '" "cv::Matx< ushort,2,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< ushort,2,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_ushort_2_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_ushort_2_1_ddot" "', argument " "2"" of type '" "cv::Matx< ushort,2,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Matx_ushort_2_1_ddot" "', argument " "2"" of type '" "cv::Matx< ushort,2,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< ushort,2,1 > * >(argp2);
result = (double)((cv::Matx< ushort,2,1 > const *)arg1)->ddot((cv::Matx< ushort,2,1 > const &)*arg2);
resultobj = SWIG_From_double(static_cast< double >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_ushort_2_1_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< ushort,2,1 > *arg1 = (cv::Matx< ushort,2,1 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
SwigValueWrapper< cv::Matx< ushort,1,2 > > result;
if (!PyArg_ParseTuple(args,(char *)"O:_Matx_ushort_2_1_t",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_ushort_2_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_ushort_2_1_t" "', argument " "1"" of type '" "cv::Matx< ushort,2,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< ushort,2,1 > * >(argp1);
result = ((cv::Matx< ushort,2,1 > const *)arg1)->t();
resultobj = SWIG_NewPointerObj((new cv::Matx< ushort,1,2 >(static_cast< const cv::Matx< ushort,1,2 >& >(result))), SWIGTYPE_p_cv__MatxT_ushort_1_2_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_ushort_2_1_mul(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< ushort,2,1 > *arg1 = (cv::Matx< ushort,2,1 > *) 0 ;
cv::Matx< ushort,2,1 > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
SwigValueWrapper< cv::Matx< ushort,2,1 > > result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_ushort_2_1_mul",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_ushort_2_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_ushort_2_1_mul" "', argument " "1"" of type '" "cv::Matx< ushort,2,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< ushort,2,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_ushort_2_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_ushort_2_1_mul" "', argument " "2"" of type '" "cv::Matx< ushort,2,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Matx_ushort_2_1_mul" "', argument " "2"" of type '" "cv::Matx< ushort,2,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< ushort,2,1 > * >(argp2);
result = ((cv::Matx< ushort,2,1 > const *)arg1)->mul((cv::Matx< ushort,2,1 > const &)*arg2);
resultobj = SWIG_NewPointerObj((new cv::Matx< ushort,2,1 >(static_cast< const cv::Matx< ushort,2,1 >& >(result))), SWIGTYPE_p_cv__MatxT_ushort_2_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_ushort_2_1_div(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< ushort,2,1 > *arg1 = (cv::Matx< ushort,2,1 > *) 0 ;
cv::Matx< ushort,2,1 > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
SwigValueWrapper< cv::Matx< ushort,2,1 > > result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_ushort_2_1_div",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_ushort_2_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_ushort_2_1_div" "', argument " "1"" of type '" "cv::Matx< ushort,2,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< ushort,2,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_ushort_2_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_ushort_2_1_div" "', argument " "2"" of type '" "cv::Matx< ushort,2,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Matx_ushort_2_1_div" "', argument " "2"" of type '" "cv::Matx< ushort,2,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< ushort,2,1 > * >(argp2);
result = ((cv::Matx< ushort,2,1 > const *)arg1)->div((cv::Matx< ushort,2,1 > const &)*arg2);
resultobj = SWIG_NewPointerObj((new cv::Matx< ushort,2,1 >(static_cast< const cv::Matx< ushort,2,1 >& >(result))), SWIGTYPE_p_cv__MatxT_ushort_2_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_ushort_2_1___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< ushort,2,1 > *arg1 = (cv::Matx< ushort,2,1 > *) 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 ;
ushort *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:_Matx_ushort_2_1___call__",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_ushort_2_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_ushort_2_1___call__" "', argument " "1"" of type '" "cv::Matx< ushort,2,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< ushort,2,1 > * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_Matx_ushort_2_1___call__" "', 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 '" "_Matx_ushort_2_1___call__" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
result = (ushort *) &((cv::Matx< ushort,2,1 > const *)arg1)->operator ()(arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ushort, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_ushort_2_1__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< ushort,2,1 > *arg1 = 0 ;
cv::Matx< ushort,2,1 > *arg2 = 0 ;
cv::Matx_AddOp 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 ;
cv::Matx< ushort,2,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Matx_ushort_2_1",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_ushort_2_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_ushort_2_1" "', argument " "1"" of type '" "cv::Matx< ushort,2,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_ushort_2_1" "', argument " "1"" of type '" "cv::Matx< ushort,2,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< ushort,2,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_ushort_2_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Matx_ushort_2_1" "', argument " "2"" of type '" "cv::Matx< ushort,2,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_ushort_2_1" "', argument " "2"" of type '" "cv::Matx< ushort,2,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< ushort,2,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_AddOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Matx_ushort_2_1" "', argument " "3"" of type '" "cv::Matx_AddOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_ushort_2_1" "', argument " "3"" of type '" "cv::Matx_AddOp""'");
} else {
cv::Matx_AddOp * temp = reinterpret_cast< cv::Matx_AddOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Matx< ushort,2,1 > *)new cv::Matx< ushort,2,1 >((cv::Matx< ushort,2,1 > const &)*arg1,(cv::Matx< ushort,2,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_ushort_2_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_ushort_2_1__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< ushort,2,1 > *arg1 = 0 ;
cv::Matx< ushort,2,1 > *arg2 = 0 ;
cv::Matx_SubOp 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 ;
cv::Matx< ushort,2,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Matx_ushort_2_1",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_ushort_2_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_ushort_2_1" "', argument " "1"" of type '" "cv::Matx< ushort,2,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_ushort_2_1" "', argument " "1"" of type '" "cv::Matx< ushort,2,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< ushort,2,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_ushort_2_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Matx_ushort_2_1" "', argument " "2"" of type '" "cv::Matx< ushort,2,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_ushort_2_1" "', argument " "2"" of type '" "cv::Matx< ushort,2,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< ushort,2,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_SubOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Matx_ushort_2_1" "', argument " "3"" of type '" "cv::Matx_SubOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_ushort_2_1" "', argument " "3"" of type '" "cv::Matx_SubOp""'");
} else {
cv::Matx_SubOp * temp = reinterpret_cast< cv::Matx_SubOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Matx< ushort,2,1 > *)new cv::Matx< ushort,2,1 >((cv::Matx< ushort,2,1 > const &)*arg1,(cv::Matx< ushort,2,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_ushort_2_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_ushort_2_1__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< ushort,2,1 > *arg1 = 0 ;
cv::Matx< ushort,2,1 > *arg2 = 0 ;
cv::Matx_MulOp 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 ;
cv::Matx< ushort,2,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Matx_ushort_2_1",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_ushort_2_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_ushort_2_1" "', argument " "1"" of type '" "cv::Matx< ushort,2,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_ushort_2_1" "', argument " "1"" of type '" "cv::Matx< ushort,2,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< ushort,2,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_ushort_2_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Matx_ushort_2_1" "', argument " "2"" of type '" "cv::Matx< ushort,2,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_ushort_2_1" "', argument " "2"" of type '" "cv::Matx< ushort,2,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< ushort,2,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_MulOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Matx_ushort_2_1" "', argument " "3"" of type '" "cv::Matx_MulOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_ushort_2_1" "', argument " "3"" of type '" "cv::Matx_MulOp""'");
} else {
cv::Matx_MulOp * temp = reinterpret_cast< cv::Matx_MulOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Matx< ushort,2,1 > *)new cv::Matx< ushort,2,1 >((cv::Matx< ushort,2,1 > const &)*arg1,(cv::Matx< ushort,2,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_ushort_2_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_ushort_2_1__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< ushort,2,1 > *arg1 = 0 ;
cv::Matx< ushort,2,1 > *arg2 = 0 ;
cv::Matx_DivOp 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 ;
cv::Matx< ushort,2,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Matx_ushort_2_1",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_ushort_2_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_ushort_2_1" "', argument " "1"" of type '" "cv::Matx< ushort,2,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_ushort_2_1" "', argument " "1"" of type '" "cv::Matx< ushort,2,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< ushort,2,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_ushort_2_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Matx_ushort_2_1" "', argument " "2"" of type '" "cv::Matx< ushort,2,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_ushort_2_1" "', argument " "2"" of type '" "cv::Matx< ushort,2,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< ushort,2,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_DivOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Matx_ushort_2_1" "', argument " "3"" of type '" "cv::Matx_DivOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_ushort_2_1" "', argument " "3"" of type '" "cv::Matx_DivOp""'");
} else {
cv::Matx_DivOp * temp = reinterpret_cast< cv::Matx_DivOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Matx< ushort,2,1 > *)new cv::Matx< ushort,2,1 >((cv::Matx< ushort,2,1 > const &)*arg1,(cv::Matx< ushort,2,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_ushort_2_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_ushort_2_1__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< ushort,1,2 > *arg1 = 0 ;
cv::Matx_TOp arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
cv::Matx< ushort,2,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:new__Matx_ushort_2_1",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_ushort_1_2_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_ushort_2_1" "', argument " "1"" of type '" "cv::Matx< ushort,1,2 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_ushort_2_1" "', argument " "1"" of type '" "cv::Matx< ushort,1,2 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< ushort,1,2 > * >(argp1);
{
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__Matx_TOp, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Matx_ushort_2_1" "', argument " "2"" of type '" "cv::Matx_TOp""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_ushort_2_1" "', argument " "2"" of type '" "cv::Matx_TOp""'");
} else {
cv::Matx_TOp * temp = reinterpret_cast< cv::Matx_TOp * >(argp2);
arg2 = *temp;
if (SWIG_IsNewObj(res2)) delete temp;
}
}
result = (cv::Matx< ushort,2,1 > *)new cv::Matx< ushort,2,1 >((cv::Matx< ushort,1,2 > const &)*arg1,arg2);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_ushort_2_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_ushort_2_1_val_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< ushort,2,1 > *arg1 = (cv::Matx< ushort,2,1 > *) 0 ;
ushort *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:_Matx_ushort_2_1_val_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_ushort_2_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_ushort_2_1_val_set" "', argument " "1"" of type '" "cv::Matx< ushort,2,1 > *""'");
}
arg1 = reinterpret_cast< cv::Matx< ushort,2,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ushort, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_ushort_2_1_val_set" "', argument " "2"" of type '" "ushort [2*1]""'");
}
arg2 = reinterpret_cast< ushort * >(argp2);
{
if (arg2) {
size_t ii = 0;
for (; ii < (size_t)2*1; ++ii) *(ushort *)&arg1->val[ii] = *((ushort *)arg2 + ii);
} else {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""val""' of type '""ushort [2*1]""'");
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_ushort_2_1_val_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< ushort,2,1 > *arg1 = (cv::Matx< ushort,2,1 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
ushort *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:_Matx_ushort_2_1_val_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_ushort_2_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_ushort_2_1_val_get" "', argument " "1"" of type '" "cv::Matx< ushort,2,1 > *""'");
}
arg1 = reinterpret_cast< cv::Matx< ushort,2,1 > * >(argp1);
result = (ushort *)(ushort *) ((arg1)->val);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ushort, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_ushort_2_1__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< cv::Matx< ushort,2,1 >::value_type,std::allocator< cv::Matx< ushort,2,1 >::value_type > > arg1 ;
PyObject * obj0 = 0 ;
cv::Matx< ushort,2,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__Matx_ushort_2_1",&obj0)) SWIG_fail;
{
std::vector< ushort,std::allocator< ushort > > *ptr = (std::vector< ushort,std::allocator< ushort > > *)0;
int res = swig::asptr(obj0, &ptr);
if (!SWIG_IsOK(res) || !ptr) {
SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new__Matx_ushort_2_1" "', argument " "1"" of type '" "std::vector< cv::Matx< ushort,2,1 >::value_type,std::allocator< cv::Matx< ushort,2,1 >::value_type > >""'");
}
arg1 = *ptr;
if (SWIG_IsNewObj(res)) delete ptr;
}
result = (cv::Matx< ushort,2,1 > *)new_cv_Matx_Sl_ushort_Sc_2_Sc_1_Sg___SWIG_6(arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_ushort_2_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_ushort_2_1(PyObject *self, PyObject *args) {
Py_ssize_t argc;
PyObject *argv[4] = {
0
};
Py_ssize_t ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = args ? PyObject_Length(args) : 0;
for (ii = 0; (ii < 3) && (ii < argc); 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_ushort, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_ushort_2_1__SWIG_0(self, args);
}
}
if (argc == 1) {
int _v;
int res = swig::asptr(argv[0], (std::vector< ushort,std::allocator< ushort > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_ushort_2_1__SWIG_6(self, args);
}
}
if (argc == 2) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_ushort_1_2_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__Matx_TOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_ushort_2_1__SWIG_5(self, args);
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_ushort_2_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_ushort_2_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_MulOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_ushort_2_1__SWIG_3(self, args);
}
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_ushort_2_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_ushort_2_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_DivOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_ushort_2_1__SWIG_4(self, args);
}
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_ushort_2_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_ushort_2_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_AddOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_ushort_2_1__SWIG_1(self, args);
}
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_ushort_2_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_ushort_2_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_SubOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_ushort_2_1__SWIG_2(self, args);
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new__Matx_ushort_2_1'.\n"
" Possible C/C++ prototypes are:\n"
" cv::Matx< ushort,2,1 >::Matx(ushort const *)\n"
" cv::Matx< ushort,2,1 >::Matx(cv::Matx< ushort,2,1 > const &,cv::Matx< ushort,2,1 > const &,cv::Matx_AddOp)\n"
" cv::Matx< ushort,2,1 >::Matx(cv::Matx< ushort,2,1 > const &,cv::Matx< ushort,2,1 > const &,cv::Matx_SubOp)\n"
" cv::Matx< ushort,2,1 >::Matx(cv::Matx< ushort,2,1 > const &,cv::Matx< ushort,2,1 > const &,cv::Matx_MulOp)\n"
" cv::Matx< ushort,2,1 >::Matx(cv::Matx< ushort,2,1 > const &,cv::Matx< ushort,2,1 > const &,cv::Matx_DivOp)\n"
" cv::Matx< ushort,2,1 >::Matx(cv::Matx< ushort,1,2 > const &,cv::Matx_TOp)\n"
" cv::Matx< ushort,2,1 >::Matx(std::vector< cv::Matx< ushort,2,1 >::value_type,std::allocator< cv::Matx< ushort,2,1 >::value_type > >)\n");
return 0;
}
SWIGINTERN PyObject *_wrap__Matx_ushort_2_1___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< ushort,2,1 > *arg1 = (cv::Matx< ushort,2,1 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
std::string result;
if (!PyArg_ParseTuple(args,(char *)"O:_Matx_ushort_2_1___str__",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_ushort_2_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_ushort_2_1___str__" "', argument " "1"" of type '" "cv::Matx< ushort,2,1 > *""'");
}
arg1 = reinterpret_cast< cv::Matx< ushort,2,1 > * >(argp1);
result = cv_Matx_Sl_ushort_Sc_2_Sc_1_Sg____str__(arg1);
resultobj = SWIG_From_std_string(static_cast< std::string >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete__Matx_ushort_2_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< ushort,2,1 > *arg1 = (cv::Matx< ushort,2,1 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete__Matx_ushort_2_1",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_ushort_2_1_t, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__Matx_ushort_2_1" "', argument " "1"" of type '" "cv::Matx< ushort,2,1 > *""'");
}
arg1 = reinterpret_cast< cv::Matx< ushort,2,1 > * >(argp1);
delete arg1;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_Matx_ushort_2_1_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_cv__MatxT_ushort_2_1_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_new__Vec_ushort_2__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
ushort *arg1 = (ushort *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
cv::Vec< ushort,2 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__Vec_ushort_2",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ushort, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Vec_ushort_2" "', argument " "1"" of type '" "ushort const *""'");
}
arg1 = reinterpret_cast< ushort * >(argp1);
result = (cv::Vec< ushort,2 > *)new cv::Vec< ushort,2 >((ushort const *)arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__VecT_ushort_2_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Vec_ushort_2__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Vec< ushort,2 > *arg1 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
cv::Vec< ushort,2 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__Vec_ushort_2",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__VecT_ushort_2_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Vec_ushort_2" "', argument " "1"" of type '" "cv::Vec< ushort,2 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_ushort_2" "', argument " "1"" of type '" "cv::Vec< ushort,2 > const &""'");
}
arg1 = reinterpret_cast< cv::Vec< ushort,2 > * >(argp1);
result = (cv::Vec< ushort,2 > *)new cv::Vec< ushort,2 >((cv::Vec< ushort,2 > const &)*arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__VecT_ushort_2_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Vec_ushort_2_all(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
ushort arg1 ;
void *argp1 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
SwigValueWrapper< cv::Vec< ushort,2 > > result;
if (!PyArg_ParseTuple(args,(char *)"O:_Vec_ushort_2_all",&obj0)) SWIG_fail;
{
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_ushort, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Vec_ushort_2_all" "', argument " "1"" of type '" "ushort""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Vec_ushort_2_all" "', argument " "1"" of type '" "ushort""'");
} else {
ushort * temp = reinterpret_cast< ushort * >(argp1);
arg1 = *temp;
if (SWIG_IsNewObj(res1)) delete temp;
}
}
result = cv::Vec< ushort,2 >::SWIGTEMPLATEDISAMBIGUATOR all(arg1);
resultobj = SWIG_NewPointerObj((new cv::Vec< ushort,2 >(static_cast< const cv::Vec< ushort,2 >& >(result))), SWIGTYPE_p_cv__VecT_ushort_2_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Vec_ushort_2_mul(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Vec< ushort,2 > *arg1 = (cv::Vec< ushort,2 > *) 0 ;
cv::Vec< ushort,2 > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
SwigValueWrapper< cv::Vec< ushort,2 > > result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Vec_ushort_2_mul",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__VecT_ushort_2_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Vec_ushort_2_mul" "', argument " "1"" of type '" "cv::Vec< ushort,2 > const *""'");
}
arg1 = reinterpret_cast< cv::Vec< ushort,2 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__VecT_ushort_2_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Vec_ushort_2_mul" "', argument " "2"" of type '" "cv::Vec< ushort,2 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Vec_ushort_2_mul" "', argument " "2"" of type '" "cv::Vec< ushort,2 > const &""'");
}
arg2 = reinterpret_cast< cv::Vec< ushort,2 > * >(argp2);
result = ((cv::Vec< ushort,2 > const *)arg1)->mul((cv::Vec< ushort,2 > const &)*arg2);
resultobj = SWIG_NewPointerObj((new cv::Vec< ushort,2 >(static_cast< const cv::Vec< ushort,2 >& >(result))), SWIGTYPE_p_cv__VecT_ushort_2_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Vec_ushort_2___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Vec< ushort,2 > *arg1 = (cv::Vec< ushort,2 > *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
ushort *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:_Vec_ushort_2___call__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__VecT_ushort_2_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Vec_ushort_2___call__" "', argument " "1"" of type '" "cv::Vec< ushort,2 > const *""'");
}
arg1 = reinterpret_cast< cv::Vec< ushort,2 > * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_Vec_ushort_2___call__" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
result = (ushort *) &((cv::Vec< ushort,2 > const *)arg1)->operator ()(arg2);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ushort, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Vec_ushort_2__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< ushort,2,1 > *arg1 = 0 ;
cv::Matx< ushort,2,1 > *arg2 = 0 ;
cv::Matx_AddOp 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 ;
cv::Vec< ushort,2 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Vec_ushort_2",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_ushort_2_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Vec_ushort_2" "', argument " "1"" of type '" "cv::Matx< ushort,2,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_ushort_2" "', argument " "1"" of type '" "cv::Matx< ushort,2,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< ushort,2,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_ushort_2_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Vec_ushort_2" "', argument " "2"" of type '" "cv::Matx< ushort,2,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_ushort_2" "', argument " "2"" of type '" "cv::Matx< ushort,2,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< ushort,2,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_AddOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Vec_ushort_2" "', argument " "3"" of type '" "cv::Matx_AddOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_ushort_2" "', argument " "3"" of type '" "cv::Matx_AddOp""'");
} else {
cv::Matx_AddOp * temp = reinterpret_cast< cv::Matx_AddOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Vec< ushort,2 > *)new cv::Vec< ushort,2 >((cv::Matx< ushort,2,1 > const &)*arg1,(cv::Matx< ushort,2,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__VecT_ushort_2_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Vec_ushort_2__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< ushort,2,1 > *arg1 = 0 ;
cv::Matx< ushort,2,1 > *arg2 = 0 ;
cv::Matx_SubOp 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 ;
cv::Vec< ushort,2 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Vec_ushort_2",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_ushort_2_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Vec_ushort_2" "', argument " "1"" of type '" "cv::Matx< ushort,2,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_ushort_2" "', argument " "1"" of type '" "cv::Matx< ushort,2,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< ushort,2,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_ushort_2_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Vec_ushort_2" "', argument " "2"" of type '" "cv::Matx< ushort,2,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_ushort_2" "', argument " "2"" of type '" "cv::Matx< ushort,2,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< ushort,2,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_SubOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Vec_ushort_2" "', argument " "3"" of type '" "cv::Matx_SubOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_ushort_2" "', argument " "3"" of type '" "cv::Matx_SubOp""'");
} else {
cv::Matx_SubOp * temp = reinterpret_cast< cv::Matx_SubOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Vec< ushort,2 > *)new cv::Vec< ushort,2 >((cv::Matx< ushort,2,1 > const &)*arg1,(cv::Matx< ushort,2,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__VecT_ushort_2_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Vec_ushort_2__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< cv::Vec< ushort,2 >::value_type,std::allocator< cv::Vec< ushort,2 >::value_type > > arg1 ;
PyObject * obj0 = 0 ;
cv::Vec< ushort,2 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__Vec_ushort_2",&obj0)) SWIG_fail;
{
std::vector< ushort,std::allocator< ushort > > *ptr = (std::vector< ushort,std::allocator< ushort > > *)0;
int res = swig::asptr(obj0, &ptr);
if (!SWIG_IsOK(res) || !ptr) {
SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new__Vec_ushort_2" "', argument " "1"" of type '" "std::vector< cv::Vec< ushort,2 >::value_type,std::allocator< cv::Vec< ushort,2 >::value_type > >""'");
}
arg1 = *ptr;
if (SWIG_IsNewObj(res)) delete ptr;
}
result = (cv::Vec< ushort,2 > *)new_cv_Vec_Sl_ushort_Sc_2_Sg___SWIG_4(arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__VecT_ushort_2_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Vec_ushort_2(PyObject *self, PyObject *args) {
Py_ssize_t argc;
PyObject *argv[4] = {
0
};
Py_ssize_t ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = args ? PyObject_Length(args) : 0;
for (ii = 0; (ii < 3) && (ii < argc); 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_ushort, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Vec_ushort_2__SWIG_0(self, args);
}
}
if (argc == 1) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__VecT_ushort_2_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Vec_ushort_2__SWIG_1(self, args);
}
}
if (argc == 1) {
int _v;
int res = swig::asptr(argv[0], (std::vector< ushort,std::allocator< ushort > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Vec_ushort_2__SWIG_4(self, args);
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_ushort_2_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_ushort_2_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_SubOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Vec_ushort_2__SWIG_3(self, args);
}
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_ushort_2_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_ushort_2_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_AddOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Vec_ushort_2__SWIG_2(self, args);
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new__Vec_ushort_2'.\n"
" Possible C/C++ prototypes are:\n"
" cv::Vec< ushort,2 >::Vec(ushort const *)\n"
" cv::Vec< ushort,2 >::Vec(cv::Vec< ushort,2 > const &)\n"
" cv::Vec< ushort,2 >::Vec(cv::Matx< ushort,2,1 > const &,cv::Matx< ushort,2,1 > const &,cv::Matx_AddOp)\n"
" cv::Vec< ushort,2 >::Vec(cv::Matx< ushort,2,1 > const &,cv::Matx< ushort,2,1 > const &,cv::Matx_SubOp)\n"
" cv::Vec< ushort,2 >::Vec(std::vector< cv::Vec< ushort,2 >::value_type,std::allocator< cv::Vec< ushort,2 >::value_type > >)\n");
return 0;
}
SWIGINTERN PyObject *_wrap__Vec_ushort_2___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Vec< ushort,2 > *arg1 = (cv::Vec< ushort,2 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
std::string result;
if (!PyArg_ParseTuple(args,(char *)"O:_Vec_ushort_2___str__",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__VecT_ushort_2_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Vec_ushort_2___str__" "', argument " "1"" of type '" "cv::Vec< ushort,2 > *""'");
}
arg1 = reinterpret_cast< cv::Vec< ushort,2 > * >(argp1);
result = cv_Vec_Sl_ushort_Sc_2_Sg____str__(arg1);
resultobj = SWIG_From_std_string(static_cast< std::string >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete__Vec_ushort_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Vec< ushort,2 > *arg1 = (cv::Vec< ushort,2 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete__Vec_ushort_2",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__VecT_ushort_2_t, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__Vec_ushort_2" "', argument " "1"" of type '" "cv::Vec< ushort,2 > *""'");
}
arg1 = reinterpret_cast< cv::Vec< ushort,2 > * >(argp1);
delete arg1;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_Vec_ushort_2_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_cv__VecT_ushort_2_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_new__DataType_Vec_ushort_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::DataType< cv::Vec< ushort,2 > > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new__DataType_Vec_ushort_2")) SWIG_fail;
result = (cv::DataType< cv::Vec< ushort,2 > > *)new cv::DataType< cv::Vec< ushort,2 > >();
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__DataTypeT_cv__VecT_ushort_2_t_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete__DataType_Vec_ushort_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::DataType< cv::Vec< ushort,2 > > *arg1 = (cv::DataType< cv::Vec< ushort,2 > > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete__DataType_Vec_ushort_2",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__DataTypeT_cv__VecT_ushort_2_t_t, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__DataType_Vec_ushort_2" "', argument " "1"" of type '" "cv::DataType< cv::Vec< ushort,2 > > *""'");
}
arg1 = reinterpret_cast< cv::DataType< cv::Vec< ushort,2 > > * >(argp1);
delete arg1;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_DataType_Vec_ushort_2_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_cv__DataTypeT_cv__VecT_ushort_2_t_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_new__Matx_ushort_3_1__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
ushort *arg1 = (ushort *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
cv::Matx< ushort,3,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__Matx_ushort_3_1",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ushort, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_ushort_3_1" "', argument " "1"" of type '" "ushort const *""'");
}
arg1 = reinterpret_cast< ushort * >(argp1);
result = (cv::Matx< ushort,3,1 > *)new cv::Matx< ushort,3,1 >((ushort const *)arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_ushort_3_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_ushort_3_1_all(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
ushort arg1 ;
void *argp1 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
SwigValueWrapper< cv::Matx< ushort,3,1 > > result;
if (!PyArg_ParseTuple(args,(char *)"O:_Matx_ushort_3_1_all",&obj0)) SWIG_fail;
{
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_ushort, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_ushort_3_1_all" "', argument " "1"" of type '" "ushort""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Matx_ushort_3_1_all" "', argument " "1"" of type '" "ushort""'");
} else {
ushort * temp = reinterpret_cast< ushort * >(argp1);
arg1 = *temp;
if (SWIG_IsNewObj(res1)) delete temp;
}
}
result = cv::Matx< ushort,3,1 >::SWIGTEMPLATEDISAMBIGUATOR all(arg1);
resultobj = SWIG_NewPointerObj((new cv::Matx< ushort,3,1 >(static_cast< const cv::Matx< ushort,3,1 >& >(result))), SWIGTYPE_p_cv__MatxT_ushort_3_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_ushort_3_1_zeros(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
SwigValueWrapper< cv::Matx< ushort,3,1 > > result;
if (!PyArg_ParseTuple(args,(char *)":_Matx_ushort_3_1_zeros")) SWIG_fail;
result = cv::Matx< ushort,3,1 >::SWIGTEMPLATEDISAMBIGUATOR zeros();
resultobj = SWIG_NewPointerObj((new cv::Matx< ushort,3,1 >(static_cast< const cv::Matx< ushort,3,1 >& >(result))), SWIGTYPE_p_cv__MatxT_ushort_3_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_ushort_3_1_ones(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
SwigValueWrapper< cv::Matx< ushort,3,1 > > result;
if (!PyArg_ParseTuple(args,(char *)":_Matx_ushort_3_1_ones")) SWIG_fail;
result = cv::Matx< ushort,3,1 >::SWIGTEMPLATEDISAMBIGUATOR ones();
resultobj = SWIG_NewPointerObj((new cv::Matx< ushort,3,1 >(static_cast< const cv::Matx< ushort,3,1 >& >(result))), SWIGTYPE_p_cv__MatxT_ushort_3_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_ushort_3_1_eye(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
SwigValueWrapper< cv::Matx< ushort,3,1 > > result;
if (!PyArg_ParseTuple(args,(char *)":_Matx_ushort_3_1_eye")) SWIG_fail;
result = cv::Matx< ushort,3,1 >::SWIGTEMPLATEDISAMBIGUATOR eye();
resultobj = SWIG_NewPointerObj((new cv::Matx< ushort,3,1 >(static_cast< const cv::Matx< ushort,3,1 >& >(result))), SWIGTYPE_p_cv__MatxT_ushort_3_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_ushort_3_1_randu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
ushort arg1 ;
ushort arg2 ;
void *argp1 ;
int res1 = 0 ;
void *argp2 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
SwigValueWrapper< cv::Matx< ushort,3,1 > > result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_ushort_3_1_randu",&obj0,&obj1)) SWIG_fail;
{
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_ushort, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_ushort_3_1_randu" "', argument " "1"" of type '" "ushort""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Matx_ushort_3_1_randu" "', argument " "1"" of type '" "ushort""'");
} else {
ushort * temp = reinterpret_cast< ushort * >(argp1);
arg1 = *temp;
if (SWIG_IsNewObj(res1)) delete temp;
}
}
{
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_ushort, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_ushort_3_1_randu" "', argument " "2"" of type '" "ushort""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Matx_ushort_3_1_randu" "', argument " "2"" of type '" "ushort""'");
} else {
ushort * temp = reinterpret_cast< ushort * >(argp2);
arg2 = *temp;
if (SWIG_IsNewObj(res2)) delete temp;
}
}
result = cv::Matx< ushort,3,1 >::SWIGTEMPLATEDISAMBIGUATOR randu(arg1,arg2);
resultobj = SWIG_NewPointerObj((new cv::Matx< ushort,3,1 >(static_cast< const cv::Matx< ushort,3,1 >& >(result))), SWIGTYPE_p_cv__MatxT_ushort_3_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_ushort_3_1_randn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
ushort arg1 ;
ushort arg2 ;
void *argp1 ;
int res1 = 0 ;
void *argp2 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
SwigValueWrapper< cv::Matx< ushort,3,1 > > result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_ushort_3_1_randn",&obj0,&obj1)) SWIG_fail;
{
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_ushort, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_ushort_3_1_randn" "', argument " "1"" of type '" "ushort""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Matx_ushort_3_1_randn" "', argument " "1"" of type '" "ushort""'");
} else {
ushort * temp = reinterpret_cast< ushort * >(argp1);
arg1 = *temp;
if (SWIG_IsNewObj(res1)) delete temp;
}
}
{
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_ushort, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_ushort_3_1_randn" "', argument " "2"" of type '" "ushort""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Matx_ushort_3_1_randn" "', argument " "2"" of type '" "ushort""'");
} else {
ushort * temp = reinterpret_cast< ushort * >(argp2);
arg2 = *temp;
if (SWIG_IsNewObj(res2)) delete temp;
}
}
result = cv::Matx< ushort,3,1 >::SWIGTEMPLATEDISAMBIGUATOR randn(arg1,arg2);
resultobj = SWIG_NewPointerObj((new cv::Matx< ushort,3,1 >(static_cast< const cv::Matx< ushort,3,1 >& >(result))), SWIGTYPE_p_cv__MatxT_ushort_3_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_ushort_3_1_dot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< ushort,3,1 > *arg1 = (cv::Matx< ushort,3,1 > *) 0 ;
cv::Matx< ushort,3,1 > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
ushort result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_ushort_3_1_dot",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_ushort_3_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_ushort_3_1_dot" "', argument " "1"" of type '" "cv::Matx< ushort,3,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< ushort,3,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_ushort_3_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_ushort_3_1_dot" "', argument " "2"" of type '" "cv::Matx< ushort,3,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Matx_ushort_3_1_dot" "', argument " "2"" of type '" "cv::Matx< ushort,3,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< ushort,3,1 > * >(argp2);
result = ((cv::Matx< ushort,3,1 > const *)arg1)->dot((cv::Matx< ushort,3,1 > const &)*arg2);
resultobj = SWIG_NewPointerObj((new ushort(static_cast< const ushort& >(result))), SWIGTYPE_p_ushort, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_ushort_3_1_ddot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< ushort,3,1 > *arg1 = (cv::Matx< ushort,3,1 > *) 0 ;
cv::Matx< ushort,3,1 > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
double result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_ushort_3_1_ddot",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_ushort_3_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_ushort_3_1_ddot" "', argument " "1"" of type '" "cv::Matx< ushort,3,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< ushort,3,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_ushort_3_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_ushort_3_1_ddot" "', argument " "2"" of type '" "cv::Matx< ushort,3,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Matx_ushort_3_1_ddot" "', argument " "2"" of type '" "cv::Matx< ushort,3,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< ushort,3,1 > * >(argp2);
result = (double)((cv::Matx< ushort,3,1 > const *)arg1)->ddot((cv::Matx< ushort,3,1 > const &)*arg2);
resultobj = SWIG_From_double(static_cast< double >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_ushort_3_1_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< ushort,3,1 > *arg1 = (cv::Matx< ushort,3,1 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
SwigValueWrapper< cv::Matx< ushort,1,3 > > result;
if (!PyArg_ParseTuple(args,(char *)"O:_Matx_ushort_3_1_t",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_ushort_3_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_ushort_3_1_t" "', argument " "1"" of type '" "cv::Matx< ushort,3,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< ushort,3,1 > * >(argp1);
result = ((cv::Matx< ushort,3,1 > const *)arg1)->t();
resultobj = SWIG_NewPointerObj((new cv::Matx< ushort,1,3 >(static_cast< const cv::Matx< ushort,1,3 >& >(result))), SWIGTYPE_p_cv__MatxT_ushort_1_3_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_ushort_3_1_mul(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< ushort,3,1 > *arg1 = (cv::Matx< ushort,3,1 > *) 0 ;
cv::Matx< ushort,3,1 > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
SwigValueWrapper< cv::Matx< ushort,3,1 > > result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_ushort_3_1_mul",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_ushort_3_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_ushort_3_1_mul" "', argument " "1"" of type '" "cv::Matx< ushort,3,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< ushort,3,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_ushort_3_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_ushort_3_1_mul" "', argument " "2"" of type '" "cv::Matx< ushort,3,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Matx_ushort_3_1_mul" "', argument " "2"" of type '" "cv::Matx< ushort,3,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< ushort,3,1 > * >(argp2);
result = ((cv::Matx< ushort,3,1 > const *)arg1)->mul((cv::Matx< ushort,3,1 > const &)*arg2);
resultobj = SWIG_NewPointerObj((new cv::Matx< ushort,3,1 >(static_cast< const cv::Matx< ushort,3,1 >& >(result))), SWIGTYPE_p_cv__MatxT_ushort_3_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_ushort_3_1_div(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< ushort,3,1 > *arg1 = (cv::Matx< ushort,3,1 > *) 0 ;
cv::Matx< ushort,3,1 > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
SwigValueWrapper< cv::Matx< ushort,3,1 > > result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_ushort_3_1_div",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_ushort_3_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_ushort_3_1_div" "', argument " "1"" of type '" "cv::Matx< ushort,3,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< ushort,3,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_ushort_3_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_ushort_3_1_div" "', argument " "2"" of type '" "cv::Matx< ushort,3,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Matx_ushort_3_1_div" "', argument " "2"" of type '" "cv::Matx< ushort,3,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< ushort,3,1 > * >(argp2);
result = ((cv::Matx< ushort,3,1 > const *)arg1)->div((cv::Matx< ushort,3,1 > const &)*arg2);
resultobj = SWIG_NewPointerObj((new cv::Matx< ushort,3,1 >(static_cast< const cv::Matx< ushort,3,1 >& >(result))), SWIGTYPE_p_cv__MatxT_ushort_3_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_ushort_3_1___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< ushort,3,1 > *arg1 = (cv::Matx< ushort,3,1 > *) 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 ;
ushort *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:_Matx_ushort_3_1___call__",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_ushort_3_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_ushort_3_1___call__" "', argument " "1"" of type '" "cv::Matx< ushort,3,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< ushort,3,1 > * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_Matx_ushort_3_1___call__" "', 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 '" "_Matx_ushort_3_1___call__" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
result = (ushort *) &((cv::Matx< ushort,3,1 > const *)arg1)->operator ()(arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ushort, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_ushort_3_1__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< ushort,3,1 > *arg1 = 0 ;
cv::Matx< ushort,3,1 > *arg2 = 0 ;
cv::Matx_AddOp 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 ;
cv::Matx< ushort,3,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Matx_ushort_3_1",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_ushort_3_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_ushort_3_1" "', argument " "1"" of type '" "cv::Matx< ushort,3,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_ushort_3_1" "', argument " "1"" of type '" "cv::Matx< ushort,3,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< ushort,3,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_ushort_3_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Matx_ushort_3_1" "', argument " "2"" of type '" "cv::Matx< ushort,3,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_ushort_3_1" "', argument " "2"" of type '" "cv::Matx< ushort,3,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< ushort,3,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_AddOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Matx_ushort_3_1" "', argument " "3"" of type '" "cv::Matx_AddOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_ushort_3_1" "', argument " "3"" of type '" "cv::Matx_AddOp""'");
} else {
cv::Matx_AddOp * temp = reinterpret_cast< cv::Matx_AddOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Matx< ushort,3,1 > *)new cv::Matx< ushort,3,1 >((cv::Matx< ushort,3,1 > const &)*arg1,(cv::Matx< ushort,3,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_ushort_3_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_ushort_3_1__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< ushort,3,1 > *arg1 = 0 ;
cv::Matx< ushort,3,1 > *arg2 = 0 ;
cv::Matx_SubOp 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 ;
cv::Matx< ushort,3,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Matx_ushort_3_1",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_ushort_3_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_ushort_3_1" "', argument " "1"" of type '" "cv::Matx< ushort,3,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_ushort_3_1" "', argument " "1"" of type '" "cv::Matx< ushort,3,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< ushort,3,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_ushort_3_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Matx_ushort_3_1" "', argument " "2"" of type '" "cv::Matx< ushort,3,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_ushort_3_1" "', argument " "2"" of type '" "cv::Matx< ushort,3,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< ushort,3,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_SubOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Matx_ushort_3_1" "', argument " "3"" of type '" "cv::Matx_SubOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_ushort_3_1" "', argument " "3"" of type '" "cv::Matx_SubOp""'");
} else {
cv::Matx_SubOp * temp = reinterpret_cast< cv::Matx_SubOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Matx< ushort,3,1 > *)new cv::Matx< ushort,3,1 >((cv::Matx< ushort,3,1 > const &)*arg1,(cv::Matx< ushort,3,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_ushort_3_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_ushort_3_1__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< ushort,3,1 > *arg1 = 0 ;
cv::Matx< ushort,3,1 > *arg2 = 0 ;
cv::Matx_MulOp 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 ;
cv::Matx< ushort,3,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Matx_ushort_3_1",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_ushort_3_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_ushort_3_1" "', argument " "1"" of type '" "cv::Matx< ushort,3,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_ushort_3_1" "', argument " "1"" of type '" "cv::Matx< ushort,3,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< ushort,3,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_ushort_3_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Matx_ushort_3_1" "', argument " "2"" of type '" "cv::Matx< ushort,3,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_ushort_3_1" "', argument " "2"" of type '" "cv::Matx< ushort,3,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< ushort,3,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_MulOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Matx_ushort_3_1" "', argument " "3"" of type '" "cv::Matx_MulOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_ushort_3_1" "', argument " "3"" of type '" "cv::Matx_MulOp""'");
} else {
cv::Matx_MulOp * temp = reinterpret_cast< cv::Matx_MulOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Matx< ushort,3,1 > *)new cv::Matx< ushort,3,1 >((cv::Matx< ushort,3,1 > const &)*arg1,(cv::Matx< ushort,3,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_ushort_3_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_ushort_3_1__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< ushort,3,1 > *arg1 = 0 ;
cv::Matx< ushort,3,1 > *arg2 = 0 ;
cv::Matx_DivOp 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 ;
cv::Matx< ushort,3,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Matx_ushort_3_1",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_ushort_3_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_ushort_3_1" "', argument " "1"" of type '" "cv::Matx< ushort,3,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_ushort_3_1" "', argument " "1"" of type '" "cv::Matx< ushort,3,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< ushort,3,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_ushort_3_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Matx_ushort_3_1" "', argument " "2"" of type '" "cv::Matx< ushort,3,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_ushort_3_1" "', argument " "2"" of type '" "cv::Matx< ushort,3,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< ushort,3,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_DivOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Matx_ushort_3_1" "', argument " "3"" of type '" "cv::Matx_DivOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_ushort_3_1" "', argument " "3"" of type '" "cv::Matx_DivOp""'");
} else {
cv::Matx_DivOp * temp = reinterpret_cast< cv::Matx_DivOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Matx< ushort,3,1 > *)new cv::Matx< ushort,3,1 >((cv::Matx< ushort,3,1 > const &)*arg1,(cv::Matx< ushort,3,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_ushort_3_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_ushort_3_1__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< ushort,1,3 > *arg1 = 0 ;
cv::Matx_TOp arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
cv::Matx< ushort,3,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:new__Matx_ushort_3_1",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_ushort_1_3_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_ushort_3_1" "', argument " "1"" of type '" "cv::Matx< ushort,1,3 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_ushort_3_1" "', argument " "1"" of type '" "cv::Matx< ushort,1,3 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< ushort,1,3 > * >(argp1);
{
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__Matx_TOp, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Matx_ushort_3_1" "', argument " "2"" of type '" "cv::Matx_TOp""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_ushort_3_1" "', argument " "2"" of type '" "cv::Matx_TOp""'");
} else {
cv::Matx_TOp * temp = reinterpret_cast< cv::Matx_TOp * >(argp2);
arg2 = *temp;
if (SWIG_IsNewObj(res2)) delete temp;
}
}
result = (cv::Matx< ushort,3,1 > *)new cv::Matx< ushort,3,1 >((cv::Matx< ushort,1,3 > const &)*arg1,arg2);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_ushort_3_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_ushort_3_1_val_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< ushort,3,1 > *arg1 = (cv::Matx< ushort,3,1 > *) 0 ;
ushort *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:_Matx_ushort_3_1_val_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_ushort_3_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_ushort_3_1_val_set" "', argument " "1"" of type '" "cv::Matx< ushort,3,1 > *""'");
}
arg1 = reinterpret_cast< cv::Matx< ushort,3,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ushort, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_ushort_3_1_val_set" "', argument " "2"" of type '" "ushort [3*1]""'");
}
arg2 = reinterpret_cast< ushort * >(argp2);
{
if (arg2) {
size_t ii = 0;
for (; ii < (size_t)3*1; ++ii) *(ushort *)&arg1->val[ii] = *((ushort *)arg2 + ii);
} else {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""val""' of type '""ushort [3*1]""'");
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_ushort_3_1_val_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< ushort,3,1 > *arg1 = (cv::Matx< ushort,3,1 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
ushort *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:_Matx_ushort_3_1_val_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_ushort_3_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_ushort_3_1_val_get" "', argument " "1"" of type '" "cv::Matx< ushort,3,1 > *""'");
}
arg1 = reinterpret_cast< cv::Matx< ushort,3,1 > * >(argp1);
result = (ushort *)(ushort *) ((arg1)->val);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ushort, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_ushort_3_1__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< cv::Matx< ushort,3,1 >::value_type,std::allocator< cv::Matx< ushort,3,1 >::value_type > > arg1 ;
PyObject * obj0 = 0 ;
cv::Matx< ushort,3,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__Matx_ushort_3_1",&obj0)) SWIG_fail;
{
std::vector< ushort,std::allocator< ushort > > *ptr = (std::vector< ushort,std::allocator< ushort > > *)0;
int res = swig::asptr(obj0, &ptr);
if (!SWIG_IsOK(res) || !ptr) {
SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new__Matx_ushort_3_1" "', argument " "1"" of type '" "std::vector< cv::Matx< ushort,3,1 >::value_type,std::allocator< cv::Matx< ushort,3,1 >::value_type > >""'");
}
arg1 = *ptr;
if (SWIG_IsNewObj(res)) delete ptr;
}
result = (cv::Matx< ushort,3,1 > *)new_cv_Matx_Sl_ushort_Sc_3_Sc_1_Sg___SWIG_6(arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_ushort_3_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_ushort_3_1(PyObject *self, PyObject *args) {
Py_ssize_t argc;
PyObject *argv[4] = {
0
};
Py_ssize_t ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = args ? PyObject_Length(args) : 0;
for (ii = 0; (ii < 3) && (ii < argc); 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_ushort, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_ushort_3_1__SWIG_0(self, args);
}
}
if (argc == 1) {
int _v;
int res = swig::asptr(argv[0], (std::vector< ushort,std::allocator< ushort > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_ushort_3_1__SWIG_6(self, args);
}
}
if (argc == 2) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_ushort_1_3_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__Matx_TOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_ushort_3_1__SWIG_5(self, args);
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_ushort_3_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_ushort_3_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_MulOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_ushort_3_1__SWIG_3(self, args);
}
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_ushort_3_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_ushort_3_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_DivOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_ushort_3_1__SWIG_4(self, args);
}
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_ushort_3_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_ushort_3_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_AddOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_ushort_3_1__SWIG_1(self, args);
}
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_ushort_3_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_ushort_3_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_SubOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_ushort_3_1__SWIG_2(self, args);
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new__Matx_ushort_3_1'.\n"
" Possible C/C++ prototypes are:\n"
" cv::Matx< ushort,3,1 >::Matx(ushort const *)\n"
" cv::Matx< ushort,3,1 >::Matx(cv::Matx< ushort,3,1 > const &,cv::Matx< ushort,3,1 > const &,cv::Matx_AddOp)\n"
" cv::Matx< ushort,3,1 >::Matx(cv::Matx< ushort,3,1 > const &,cv::Matx< ushort,3,1 > const &,cv::Matx_SubOp)\n"
" cv::Matx< ushort,3,1 >::Matx(cv::Matx< ushort,3,1 > const &,cv::Matx< ushort,3,1 > const &,cv::Matx_MulOp)\n"
" cv::Matx< ushort,3,1 >::Matx(cv::Matx< ushort,3,1 > const &,cv::Matx< ushort,3,1 > const &,cv::Matx_DivOp)\n"
" cv::Matx< ushort,3,1 >::Matx(cv::Matx< ushort,1,3 > const &,cv::Matx_TOp)\n"
" cv::Matx< ushort,3,1 >::Matx(std::vector< cv::Matx< ushort,3,1 >::value_type,std::allocator< cv::Matx< ushort,3,1 >::value_type > >)\n");
return 0;
}
SWIGINTERN PyObject *_wrap__Matx_ushort_3_1___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< ushort,3,1 > *arg1 = (cv::Matx< ushort,3,1 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
std::string result;
if (!PyArg_ParseTuple(args,(char *)"O:_Matx_ushort_3_1___str__",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_ushort_3_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_ushort_3_1___str__" "', argument " "1"" of type '" "cv::Matx< ushort,3,1 > *""'");
}
arg1 = reinterpret_cast< cv::Matx< ushort,3,1 > * >(argp1);
result = cv_Matx_Sl_ushort_Sc_3_Sc_1_Sg____str__(arg1);
resultobj = SWIG_From_std_string(static_cast< std::string >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete__Matx_ushort_3_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< ushort,3,1 > *arg1 = (cv::Matx< ushort,3,1 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete__Matx_ushort_3_1",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_ushort_3_1_t, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__Matx_ushort_3_1" "', argument " "1"" of type '" "cv::Matx< ushort,3,1 > *""'");
}
arg1 = reinterpret_cast< cv::Matx< ushort,3,1 > * >(argp1);
delete arg1;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_Matx_ushort_3_1_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_cv__MatxT_ushort_3_1_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_new__Vec_ushort_3__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
ushort *arg1 = (ushort *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
cv::Vec< ushort,3 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__Vec_ushort_3",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ushort, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Vec_ushort_3" "', argument " "1"" of type '" "ushort const *""'");
}
arg1 = reinterpret_cast< ushort * >(argp1);
result = (cv::Vec< ushort,3 > *)new cv::Vec< ushort,3 >((ushort const *)arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__VecT_ushort_3_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Vec_ushort_3__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Vec< ushort,3 > *arg1 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
cv::Vec< ushort,3 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__Vec_ushort_3",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__VecT_ushort_3_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Vec_ushort_3" "', argument " "1"" of type '" "cv::Vec< ushort,3 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_ushort_3" "', argument " "1"" of type '" "cv::Vec< ushort,3 > const &""'");
}
arg1 = reinterpret_cast< cv::Vec< ushort,3 > * >(argp1);
result = (cv::Vec< ushort,3 > *)new cv::Vec< ushort,3 >((cv::Vec< ushort,3 > const &)*arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__VecT_ushort_3_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Vec_ushort_3_all(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
ushort arg1 ;
void *argp1 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
SwigValueWrapper< cv::Vec< ushort,3 > > result;
if (!PyArg_ParseTuple(args,(char *)"O:_Vec_ushort_3_all",&obj0)) SWIG_fail;
{
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_ushort, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Vec_ushort_3_all" "', argument " "1"" of type '" "ushort""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Vec_ushort_3_all" "', argument " "1"" of type '" "ushort""'");
} else {
ushort * temp = reinterpret_cast< ushort * >(argp1);
arg1 = *temp;
if (SWIG_IsNewObj(res1)) delete temp;
}
}
result = cv::Vec< ushort,3 >::SWIGTEMPLATEDISAMBIGUATOR all(arg1);
resultobj = SWIG_NewPointerObj((new cv::Vec< ushort,3 >(static_cast< const cv::Vec< ushort,3 >& >(result))), SWIGTYPE_p_cv__VecT_ushort_3_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Vec_ushort_3_mul(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Vec< ushort,3 > *arg1 = (cv::Vec< ushort,3 > *) 0 ;
cv::Vec< ushort,3 > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
SwigValueWrapper< cv::Vec< ushort,3 > > result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Vec_ushort_3_mul",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__VecT_ushort_3_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Vec_ushort_3_mul" "', argument " "1"" of type '" "cv::Vec< ushort,3 > const *""'");
}
arg1 = reinterpret_cast< cv::Vec< ushort,3 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__VecT_ushort_3_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Vec_ushort_3_mul" "', argument " "2"" of type '" "cv::Vec< ushort,3 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Vec_ushort_3_mul" "', argument " "2"" of type '" "cv::Vec< ushort,3 > const &""'");
}
arg2 = reinterpret_cast< cv::Vec< ushort,3 > * >(argp2);
result = ((cv::Vec< ushort,3 > const *)arg1)->mul((cv::Vec< ushort,3 > const &)*arg2);
resultobj = SWIG_NewPointerObj((new cv::Vec< ushort,3 >(static_cast< const cv::Vec< ushort,3 >& >(result))), SWIGTYPE_p_cv__VecT_ushort_3_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Vec_ushort_3___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Vec< ushort,3 > *arg1 = (cv::Vec< ushort,3 > *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
ushort *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:_Vec_ushort_3___call__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__VecT_ushort_3_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Vec_ushort_3___call__" "', argument " "1"" of type '" "cv::Vec< ushort,3 > const *""'");
}
arg1 = reinterpret_cast< cv::Vec< ushort,3 > * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_Vec_ushort_3___call__" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
result = (ushort *) &((cv::Vec< ushort,3 > const *)arg1)->operator ()(arg2);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ushort, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Vec_ushort_3__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< ushort,3,1 > *arg1 = 0 ;
cv::Matx< ushort,3,1 > *arg2 = 0 ;
cv::Matx_AddOp 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 ;
cv::Vec< ushort,3 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Vec_ushort_3",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_ushort_3_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Vec_ushort_3" "', argument " "1"" of type '" "cv::Matx< ushort,3,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_ushort_3" "', argument " "1"" of type '" "cv::Matx< ushort,3,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< ushort,3,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_ushort_3_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Vec_ushort_3" "', argument " "2"" of type '" "cv::Matx< ushort,3,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_ushort_3" "', argument " "2"" of type '" "cv::Matx< ushort,3,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< ushort,3,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_AddOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Vec_ushort_3" "', argument " "3"" of type '" "cv::Matx_AddOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_ushort_3" "', argument " "3"" of type '" "cv::Matx_AddOp""'");
} else {
cv::Matx_AddOp * temp = reinterpret_cast< cv::Matx_AddOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Vec< ushort,3 > *)new cv::Vec< ushort,3 >((cv::Matx< ushort,3,1 > const &)*arg1,(cv::Matx< ushort,3,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__VecT_ushort_3_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Vec_ushort_3__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< ushort,3,1 > *arg1 = 0 ;
cv::Matx< ushort,3,1 > *arg2 = 0 ;
cv::Matx_SubOp 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 ;
cv::Vec< ushort,3 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Vec_ushort_3",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_ushort_3_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Vec_ushort_3" "', argument " "1"" of type '" "cv::Matx< ushort,3,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_ushort_3" "', argument " "1"" of type '" "cv::Matx< ushort,3,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< ushort,3,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_ushort_3_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Vec_ushort_3" "', argument " "2"" of type '" "cv::Matx< ushort,3,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_ushort_3" "', argument " "2"" of type '" "cv::Matx< ushort,3,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< ushort,3,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_SubOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Vec_ushort_3" "', argument " "3"" of type '" "cv::Matx_SubOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_ushort_3" "', argument " "3"" of type '" "cv::Matx_SubOp""'");
} else {
cv::Matx_SubOp * temp = reinterpret_cast< cv::Matx_SubOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Vec< ushort,3 > *)new cv::Vec< ushort,3 >((cv::Matx< ushort,3,1 > const &)*arg1,(cv::Matx< ushort,3,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__VecT_ushort_3_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Vec_ushort_3__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< cv::Vec< ushort,3 >::value_type,std::allocator< cv::Vec< ushort,3 >::value_type > > arg1 ;
PyObject * obj0 = 0 ;
cv::Vec< ushort,3 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__Vec_ushort_3",&obj0)) SWIG_fail;
{
std::vector< ushort,std::allocator< ushort > > *ptr = (std::vector< ushort,std::allocator< ushort > > *)0;
int res = swig::asptr(obj0, &ptr);
if (!SWIG_IsOK(res) || !ptr) {
SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new__Vec_ushort_3" "', argument " "1"" of type '" "std::vector< cv::Vec< ushort,3 >::value_type,std::allocator< cv::Vec< ushort,3 >::value_type > >""'");
}
arg1 = *ptr;
if (SWIG_IsNewObj(res)) delete ptr;
}
result = (cv::Vec< ushort,3 > *)new_cv_Vec_Sl_ushort_Sc_3_Sg___SWIG_4(arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__VecT_ushort_3_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Vec_ushort_3(PyObject *self, PyObject *args) {
Py_ssize_t argc;
PyObject *argv[4] = {
0
};
Py_ssize_t ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = args ? PyObject_Length(args) : 0;
for (ii = 0; (ii < 3) && (ii < argc); 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_ushort, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Vec_ushort_3__SWIG_0(self, args);
}
}
if (argc == 1) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__VecT_ushort_3_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Vec_ushort_3__SWIG_1(self, args);
}
}
if (argc == 1) {
int _v;
int res = swig::asptr(argv[0], (std::vector< ushort,std::allocator< ushort > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Vec_ushort_3__SWIG_4(self, args);
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_ushort_3_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_ushort_3_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_SubOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Vec_ushort_3__SWIG_3(self, args);
}
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_ushort_3_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_ushort_3_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_AddOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Vec_ushort_3__SWIG_2(self, args);
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new__Vec_ushort_3'.\n"
" Possible C/C++ prototypes are:\n"
" cv::Vec< ushort,3 >::Vec(ushort const *)\n"
" cv::Vec< ushort,3 >::Vec(cv::Vec< ushort,3 > const &)\n"
" cv::Vec< ushort,3 >::Vec(cv::Matx< ushort,3,1 > const &,cv::Matx< ushort,3,1 > const &,cv::Matx_AddOp)\n"
" cv::Vec< ushort,3 >::Vec(cv::Matx< ushort,3,1 > const &,cv::Matx< ushort,3,1 > const &,cv::Matx_SubOp)\n"
" cv::Vec< ushort,3 >::Vec(std::vector< cv::Vec< ushort,3 >::value_type,std::allocator< cv::Vec< ushort,3 >::value_type > >)\n");
return 0;
}
SWIGINTERN PyObject *_wrap__Vec_ushort_3___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Vec< ushort,3 > *arg1 = (cv::Vec< ushort,3 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
std::string result;
if (!PyArg_ParseTuple(args,(char *)"O:_Vec_ushort_3___str__",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__VecT_ushort_3_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Vec_ushort_3___str__" "', argument " "1"" of type '" "cv::Vec< ushort,3 > *""'");
}
arg1 = reinterpret_cast< cv::Vec< ushort,3 > * >(argp1);
result = cv_Vec_Sl_ushort_Sc_3_Sg____str__(arg1);
resultobj = SWIG_From_std_string(static_cast< std::string >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete__Vec_ushort_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Vec< ushort,3 > *arg1 = (cv::Vec< ushort,3 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete__Vec_ushort_3",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__VecT_ushort_3_t, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__Vec_ushort_3" "', argument " "1"" of type '" "cv::Vec< ushort,3 > *""'");
}
arg1 = reinterpret_cast< cv::Vec< ushort,3 > * >(argp1);
delete arg1;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_Vec_ushort_3_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_cv__VecT_ushort_3_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_new__DataType_Vec_ushort_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::DataType< cv::Vec< ushort,3 > > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new__DataType_Vec_ushort_3")) SWIG_fail;
result = (cv::DataType< cv::Vec< ushort,3 > > *)new cv::DataType< cv::Vec< ushort,3 > >();
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__DataTypeT_cv__VecT_ushort_3_t_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete__DataType_Vec_ushort_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::DataType< cv::Vec< ushort,3 > > *arg1 = (cv::DataType< cv::Vec< ushort,3 > > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete__DataType_Vec_ushort_3",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__DataTypeT_cv__VecT_ushort_3_t_t, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__DataType_Vec_ushort_3" "', argument " "1"" of type '" "cv::DataType< cv::Vec< ushort,3 > > *""'");
}
arg1 = reinterpret_cast< cv::DataType< cv::Vec< ushort,3 > > * >(argp1);
delete arg1;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_DataType_Vec_ushort_3_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_cv__DataTypeT_cv__VecT_ushort_3_t_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_new__Matx_ushort_4_1__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
ushort *arg1 = (ushort *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
cv::Matx< ushort,4,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__Matx_ushort_4_1",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ushort, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_ushort_4_1" "', argument " "1"" of type '" "ushort const *""'");
}
arg1 = reinterpret_cast< ushort * >(argp1);
result = (cv::Matx< ushort,4,1 > *)new cv::Matx< ushort,4,1 >((ushort const *)arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_ushort_4_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_ushort_4_1_all(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
ushort arg1 ;
void *argp1 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
SwigValueWrapper< cv::Matx< ushort,4,1 > > result;
if (!PyArg_ParseTuple(args,(char *)"O:_Matx_ushort_4_1_all",&obj0)) SWIG_fail;
{
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_ushort, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_ushort_4_1_all" "', argument " "1"" of type '" "ushort""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Matx_ushort_4_1_all" "', argument " "1"" of type '" "ushort""'");
} else {
ushort * temp = reinterpret_cast< ushort * >(argp1);
arg1 = *temp;
if (SWIG_IsNewObj(res1)) delete temp;
}
}
result = cv::Matx< ushort,4,1 >::SWIGTEMPLATEDISAMBIGUATOR all(arg1);
resultobj = SWIG_NewPointerObj((new cv::Matx< ushort,4,1 >(static_cast< const cv::Matx< ushort,4,1 >& >(result))), SWIGTYPE_p_cv__MatxT_ushort_4_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_ushort_4_1_zeros(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
SwigValueWrapper< cv::Matx< ushort,4,1 > > result;
if (!PyArg_ParseTuple(args,(char *)":_Matx_ushort_4_1_zeros")) SWIG_fail;
result = cv::Matx< ushort,4,1 >::SWIGTEMPLATEDISAMBIGUATOR zeros();
resultobj = SWIG_NewPointerObj((new cv::Matx< ushort,4,1 >(static_cast< const cv::Matx< ushort,4,1 >& >(result))), SWIGTYPE_p_cv__MatxT_ushort_4_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_ushort_4_1_ones(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
SwigValueWrapper< cv::Matx< ushort,4,1 > > result;
if (!PyArg_ParseTuple(args,(char *)":_Matx_ushort_4_1_ones")) SWIG_fail;
result = cv::Matx< ushort,4,1 >::SWIGTEMPLATEDISAMBIGUATOR ones();
resultobj = SWIG_NewPointerObj((new cv::Matx< ushort,4,1 >(static_cast< const cv::Matx< ushort,4,1 >& >(result))), SWIGTYPE_p_cv__MatxT_ushort_4_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_ushort_4_1_eye(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
SwigValueWrapper< cv::Matx< ushort,4,1 > > result;
if (!PyArg_ParseTuple(args,(char *)":_Matx_ushort_4_1_eye")) SWIG_fail;
result = cv::Matx< ushort,4,1 >::SWIGTEMPLATEDISAMBIGUATOR eye();
resultobj = SWIG_NewPointerObj((new cv::Matx< ushort,4,1 >(static_cast< const cv::Matx< ushort,4,1 >& >(result))), SWIGTYPE_p_cv__MatxT_ushort_4_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_ushort_4_1_randu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
ushort arg1 ;
ushort arg2 ;
void *argp1 ;
int res1 = 0 ;
void *argp2 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
SwigValueWrapper< cv::Matx< ushort,4,1 > > result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_ushort_4_1_randu",&obj0,&obj1)) SWIG_fail;
{
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_ushort, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_ushort_4_1_randu" "', argument " "1"" of type '" "ushort""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Matx_ushort_4_1_randu" "', argument " "1"" of type '" "ushort""'");
} else {
ushort * temp = reinterpret_cast< ushort * >(argp1);
arg1 = *temp;
if (SWIG_IsNewObj(res1)) delete temp;
}
}
{
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_ushort, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_ushort_4_1_randu" "', argument " "2"" of type '" "ushort""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Matx_ushort_4_1_randu" "', argument " "2"" of type '" "ushort""'");
} else {
ushort * temp = reinterpret_cast< ushort * >(argp2);
arg2 = *temp;
if (SWIG_IsNewObj(res2)) delete temp;
}
}
result = cv::Matx< ushort,4,1 >::SWIGTEMPLATEDISAMBIGUATOR randu(arg1,arg2);
resultobj = SWIG_NewPointerObj((new cv::Matx< ushort,4,1 >(static_cast< const cv::Matx< ushort,4,1 >& >(result))), SWIGTYPE_p_cv__MatxT_ushort_4_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_ushort_4_1_randn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
ushort arg1 ;
ushort arg2 ;
void *argp1 ;
int res1 = 0 ;
void *argp2 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
SwigValueWrapper< cv::Matx< ushort,4,1 > > result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_ushort_4_1_randn",&obj0,&obj1)) SWIG_fail;
{
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_ushort, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_ushort_4_1_randn" "', argument " "1"" of type '" "ushort""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Matx_ushort_4_1_randn" "', argument " "1"" of type '" "ushort""'");
} else {
ushort * temp = reinterpret_cast< ushort * >(argp1);
arg1 = *temp;
if (SWIG_IsNewObj(res1)) delete temp;
}
}
{
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_ushort, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_ushort_4_1_randn" "', argument " "2"" of type '" "ushort""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Matx_ushort_4_1_randn" "', argument " "2"" of type '" "ushort""'");
} else {
ushort * temp = reinterpret_cast< ushort * >(argp2);
arg2 = *temp;
if (SWIG_IsNewObj(res2)) delete temp;
}
}
result = cv::Matx< ushort,4,1 >::SWIGTEMPLATEDISAMBIGUATOR randn(arg1,arg2);
resultobj = SWIG_NewPointerObj((new cv::Matx< ushort,4,1 >(static_cast< const cv::Matx< ushort,4,1 >& >(result))), SWIGTYPE_p_cv__MatxT_ushort_4_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_ushort_4_1_dot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< ushort,4,1 > *arg1 = (cv::Matx< ushort,4,1 > *) 0 ;
cv::Matx< ushort,4,1 > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
ushort result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_ushort_4_1_dot",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_ushort_4_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_ushort_4_1_dot" "', argument " "1"" of type '" "cv::Matx< ushort,4,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< ushort,4,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_ushort_4_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_ushort_4_1_dot" "', argument " "2"" of type '" "cv::Matx< ushort,4,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Matx_ushort_4_1_dot" "', argument " "2"" of type '" "cv::Matx< ushort,4,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< ushort,4,1 > * >(argp2);
result = ((cv::Matx< ushort,4,1 > const *)arg1)->dot((cv::Matx< ushort,4,1 > const &)*arg2);
resultobj = SWIG_NewPointerObj((new ushort(static_cast< const ushort& >(result))), SWIGTYPE_p_ushort, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_ushort_4_1_ddot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< ushort,4,1 > *arg1 = (cv::Matx< ushort,4,1 > *) 0 ;
cv::Matx< ushort,4,1 > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
double result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_ushort_4_1_ddot",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_ushort_4_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_ushort_4_1_ddot" "', argument " "1"" of type '" "cv::Matx< ushort,4,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< ushort,4,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_ushort_4_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_ushort_4_1_ddot" "', argument " "2"" of type '" "cv::Matx< ushort,4,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Matx_ushort_4_1_ddot" "', argument " "2"" of type '" "cv::Matx< ushort,4,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< ushort,4,1 > * >(argp2);
result = (double)((cv::Matx< ushort,4,1 > const *)arg1)->ddot((cv::Matx< ushort,4,1 > const &)*arg2);
resultobj = SWIG_From_double(static_cast< double >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_ushort_4_1_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< ushort,4,1 > *arg1 = (cv::Matx< ushort,4,1 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
SwigValueWrapper< cv::Matx< ushort,1,4 > > result;
if (!PyArg_ParseTuple(args,(char *)"O:_Matx_ushort_4_1_t",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_ushort_4_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_ushort_4_1_t" "', argument " "1"" of type '" "cv::Matx< ushort,4,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< ushort,4,1 > * >(argp1);
result = ((cv::Matx< ushort,4,1 > const *)arg1)->t();
resultobj = SWIG_NewPointerObj((new cv::Matx< ushort,1,4 >(static_cast< const cv::Matx< ushort,1,4 >& >(result))), SWIGTYPE_p_cv__MatxT_ushort_1_4_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_ushort_4_1_mul(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< ushort,4,1 > *arg1 = (cv::Matx< ushort,4,1 > *) 0 ;
cv::Matx< ushort,4,1 > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
SwigValueWrapper< cv::Matx< ushort,4,1 > > result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_ushort_4_1_mul",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_ushort_4_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_ushort_4_1_mul" "', argument " "1"" of type '" "cv::Matx< ushort,4,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< ushort,4,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_ushort_4_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_ushort_4_1_mul" "', argument " "2"" of type '" "cv::Matx< ushort,4,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Matx_ushort_4_1_mul" "', argument " "2"" of type '" "cv::Matx< ushort,4,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< ushort,4,1 > * >(argp2);
result = ((cv::Matx< ushort,4,1 > const *)arg1)->mul((cv::Matx< ushort,4,1 > const &)*arg2);
resultobj = SWIG_NewPointerObj((new cv::Matx< ushort,4,1 >(static_cast< const cv::Matx< ushort,4,1 >& >(result))), SWIGTYPE_p_cv__MatxT_ushort_4_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_ushort_4_1_div(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< ushort,4,1 > *arg1 = (cv::Matx< ushort,4,1 > *) 0 ;
cv::Matx< ushort,4,1 > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
SwigValueWrapper< cv::Matx< ushort,4,1 > > result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_ushort_4_1_div",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_ushort_4_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_ushort_4_1_div" "', argument " "1"" of type '" "cv::Matx< ushort,4,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< ushort,4,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_ushort_4_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_ushort_4_1_div" "', argument " "2"" of type '" "cv::Matx< ushort,4,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Matx_ushort_4_1_div" "', argument " "2"" of type '" "cv::Matx< ushort,4,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< ushort,4,1 > * >(argp2);
result = ((cv::Matx< ushort,4,1 > const *)arg1)->div((cv::Matx< ushort,4,1 > const &)*arg2);
resultobj = SWIG_NewPointerObj((new cv::Matx< ushort,4,1 >(static_cast< const cv::Matx< ushort,4,1 >& >(result))), SWIGTYPE_p_cv__MatxT_ushort_4_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_ushort_4_1___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< ushort,4,1 > *arg1 = (cv::Matx< ushort,4,1 > *) 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 ;
ushort *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:_Matx_ushort_4_1___call__",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_ushort_4_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_ushort_4_1___call__" "', argument " "1"" of type '" "cv::Matx< ushort,4,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< ushort,4,1 > * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_Matx_ushort_4_1___call__" "', 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 '" "_Matx_ushort_4_1___call__" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
result = (ushort *) &((cv::Matx< ushort,4,1 > const *)arg1)->operator ()(arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ushort, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_ushort_4_1__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< ushort,4,1 > *arg1 = 0 ;
cv::Matx< ushort,4,1 > *arg2 = 0 ;
cv::Matx_AddOp 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 ;
cv::Matx< ushort,4,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Matx_ushort_4_1",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_ushort_4_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_ushort_4_1" "', argument " "1"" of type '" "cv::Matx< ushort,4,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_ushort_4_1" "', argument " "1"" of type '" "cv::Matx< ushort,4,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< ushort,4,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_ushort_4_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Matx_ushort_4_1" "', argument " "2"" of type '" "cv::Matx< ushort,4,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_ushort_4_1" "', argument " "2"" of type '" "cv::Matx< ushort,4,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< ushort,4,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_AddOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Matx_ushort_4_1" "', argument " "3"" of type '" "cv::Matx_AddOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_ushort_4_1" "', argument " "3"" of type '" "cv::Matx_AddOp""'");
} else {
cv::Matx_AddOp * temp = reinterpret_cast< cv::Matx_AddOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Matx< ushort,4,1 > *)new cv::Matx< ushort,4,1 >((cv::Matx< ushort,4,1 > const &)*arg1,(cv::Matx< ushort,4,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_ushort_4_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_ushort_4_1__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< ushort,4,1 > *arg1 = 0 ;
cv::Matx< ushort,4,1 > *arg2 = 0 ;
cv::Matx_SubOp 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 ;
cv::Matx< ushort,4,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Matx_ushort_4_1",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_ushort_4_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_ushort_4_1" "', argument " "1"" of type '" "cv::Matx< ushort,4,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_ushort_4_1" "', argument " "1"" of type '" "cv::Matx< ushort,4,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< ushort,4,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_ushort_4_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Matx_ushort_4_1" "', argument " "2"" of type '" "cv::Matx< ushort,4,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_ushort_4_1" "', argument " "2"" of type '" "cv::Matx< ushort,4,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< ushort,4,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_SubOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Matx_ushort_4_1" "', argument " "3"" of type '" "cv::Matx_SubOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_ushort_4_1" "', argument " "3"" of type '" "cv::Matx_SubOp""'");
} else {
cv::Matx_SubOp * temp = reinterpret_cast< cv::Matx_SubOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Matx< ushort,4,1 > *)new cv::Matx< ushort,4,1 >((cv::Matx< ushort,4,1 > const &)*arg1,(cv::Matx< ushort,4,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_ushort_4_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_ushort_4_1__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< ushort,4,1 > *arg1 = 0 ;
cv::Matx< ushort,4,1 > *arg2 = 0 ;
cv::Matx_MulOp 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 ;
cv::Matx< ushort,4,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Matx_ushort_4_1",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_ushort_4_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_ushort_4_1" "', argument " "1"" of type '" "cv::Matx< ushort,4,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_ushort_4_1" "', argument " "1"" of type '" "cv::Matx< ushort,4,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< ushort,4,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_ushort_4_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Matx_ushort_4_1" "', argument " "2"" of type '" "cv::Matx< ushort,4,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_ushort_4_1" "', argument " "2"" of type '" "cv::Matx< ushort,4,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< ushort,4,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_MulOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Matx_ushort_4_1" "', argument " "3"" of type '" "cv::Matx_MulOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_ushort_4_1" "', argument " "3"" of type '" "cv::Matx_MulOp""'");
} else {
cv::Matx_MulOp * temp = reinterpret_cast< cv::Matx_MulOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Matx< ushort,4,1 > *)new cv::Matx< ushort,4,1 >((cv::Matx< ushort,4,1 > const &)*arg1,(cv::Matx< ushort,4,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_ushort_4_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_ushort_4_1__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< ushort,4,1 > *arg1 = 0 ;
cv::Matx< ushort,4,1 > *arg2 = 0 ;
cv::Matx_DivOp 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 ;
cv::Matx< ushort,4,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Matx_ushort_4_1",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_ushort_4_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_ushort_4_1" "', argument " "1"" of type '" "cv::Matx< ushort,4,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_ushort_4_1" "', argument " "1"" of type '" "cv::Matx< ushort,4,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< ushort,4,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_ushort_4_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Matx_ushort_4_1" "', argument " "2"" of type '" "cv::Matx< ushort,4,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_ushort_4_1" "', argument " "2"" of type '" "cv::Matx< ushort,4,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< ushort,4,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_DivOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Matx_ushort_4_1" "', argument " "3"" of type '" "cv::Matx_DivOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_ushort_4_1" "', argument " "3"" of type '" "cv::Matx_DivOp""'");
} else {
cv::Matx_DivOp * temp = reinterpret_cast< cv::Matx_DivOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Matx< ushort,4,1 > *)new cv::Matx< ushort,4,1 >((cv::Matx< ushort,4,1 > const &)*arg1,(cv::Matx< ushort,4,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_ushort_4_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_ushort_4_1__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< ushort,1,4 > *arg1 = 0 ;
cv::Matx_TOp arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
cv::Matx< ushort,4,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:new__Matx_ushort_4_1",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_ushort_1_4_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_ushort_4_1" "', argument " "1"" of type '" "cv::Matx< ushort,1,4 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_ushort_4_1" "', argument " "1"" of type '" "cv::Matx< ushort,1,4 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< ushort,1,4 > * >(argp1);
{
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__Matx_TOp, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Matx_ushort_4_1" "', argument " "2"" of type '" "cv::Matx_TOp""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_ushort_4_1" "', argument " "2"" of type '" "cv::Matx_TOp""'");
} else {
cv::Matx_TOp * temp = reinterpret_cast< cv::Matx_TOp * >(argp2);
arg2 = *temp;
if (SWIG_IsNewObj(res2)) delete temp;
}
}
result = (cv::Matx< ushort,4,1 > *)new cv::Matx< ushort,4,1 >((cv::Matx< ushort,1,4 > const &)*arg1,arg2);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_ushort_4_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_ushort_4_1_val_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< ushort,4,1 > *arg1 = (cv::Matx< ushort,4,1 > *) 0 ;
ushort *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:_Matx_ushort_4_1_val_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_ushort_4_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_ushort_4_1_val_set" "', argument " "1"" of type '" "cv::Matx< ushort,4,1 > *""'");
}
arg1 = reinterpret_cast< cv::Matx< ushort,4,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ushort, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_ushort_4_1_val_set" "', argument " "2"" of type '" "ushort [4*1]""'");
}
arg2 = reinterpret_cast< ushort * >(argp2);
{
if (arg2) {
size_t ii = 0;
for (; ii < (size_t)4*1; ++ii) *(ushort *)&arg1->val[ii] = *((ushort *)arg2 + ii);
} else {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""val""' of type '""ushort [4*1]""'");
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_ushort_4_1_val_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< ushort,4,1 > *arg1 = (cv::Matx< ushort,4,1 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
ushort *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:_Matx_ushort_4_1_val_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_ushort_4_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_ushort_4_1_val_get" "', argument " "1"" of type '" "cv::Matx< ushort,4,1 > *""'");
}
arg1 = reinterpret_cast< cv::Matx< ushort,4,1 > * >(argp1);
result = (ushort *)(ushort *) ((arg1)->val);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ushort, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_ushort_4_1__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< cv::Matx< ushort,4,1 >::value_type,std::allocator< cv::Matx< ushort,4,1 >::value_type > > arg1 ;
PyObject * obj0 = 0 ;
cv::Matx< ushort,4,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__Matx_ushort_4_1",&obj0)) SWIG_fail;
{
std::vector< ushort,std::allocator< ushort > > *ptr = (std::vector< ushort,std::allocator< ushort > > *)0;
int res = swig::asptr(obj0, &ptr);
if (!SWIG_IsOK(res) || !ptr) {
SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new__Matx_ushort_4_1" "', argument " "1"" of type '" "std::vector< cv::Matx< ushort,4,1 >::value_type,std::allocator< cv::Matx< ushort,4,1 >::value_type > >""'");
}
arg1 = *ptr;
if (SWIG_IsNewObj(res)) delete ptr;
}
result = (cv::Matx< ushort,4,1 > *)new_cv_Matx_Sl_ushort_Sc_4_Sc_1_Sg___SWIG_6(arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_ushort_4_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_ushort_4_1(PyObject *self, PyObject *args) {
Py_ssize_t argc;
PyObject *argv[4] = {
0
};
Py_ssize_t ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = args ? PyObject_Length(args) : 0;
for (ii = 0; (ii < 3) && (ii < argc); 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_ushort, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_ushort_4_1__SWIG_0(self, args);
}
}
if (argc == 1) {
int _v;
int res = swig::asptr(argv[0], (std::vector< ushort,std::allocator< ushort > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_ushort_4_1__SWIG_6(self, args);
}
}
if (argc == 2) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_ushort_1_4_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__Matx_TOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_ushort_4_1__SWIG_5(self, args);
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_ushort_4_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_ushort_4_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_MulOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_ushort_4_1__SWIG_3(self, args);
}
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_ushort_4_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_ushort_4_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_DivOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_ushort_4_1__SWIG_4(self, args);
}
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_ushort_4_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_ushort_4_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_AddOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_ushort_4_1__SWIG_1(self, args);
}
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_ushort_4_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_ushort_4_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_SubOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_ushort_4_1__SWIG_2(self, args);
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new__Matx_ushort_4_1'.\n"
" Possible C/C++ prototypes are:\n"
" cv::Matx< ushort,4,1 >::Matx(ushort const *)\n"
" cv::Matx< ushort,4,1 >::Matx(cv::Matx< ushort,4,1 > const &,cv::Matx< ushort,4,1 > const &,cv::Matx_AddOp)\n"
" cv::Matx< ushort,4,1 >::Matx(cv::Matx< ushort,4,1 > const &,cv::Matx< ushort,4,1 > const &,cv::Matx_SubOp)\n"
" cv::Matx< ushort,4,1 >::Matx(cv::Matx< ushort,4,1 > const &,cv::Matx< ushort,4,1 > const &,cv::Matx_MulOp)\n"
" cv::Matx< ushort,4,1 >::Matx(cv::Matx< ushort,4,1 > const &,cv::Matx< ushort,4,1 > const &,cv::Matx_DivOp)\n"
" cv::Matx< ushort,4,1 >::Matx(cv::Matx< ushort,1,4 > const &,cv::Matx_TOp)\n"
" cv::Matx< ushort,4,1 >::Matx(std::vector< cv::Matx< ushort,4,1 >::value_type,std::allocator< cv::Matx< ushort,4,1 >::value_type > >)\n");
return 0;
}
SWIGINTERN PyObject *_wrap__Matx_ushort_4_1___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< ushort,4,1 > *arg1 = (cv::Matx< ushort,4,1 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
std::string result;
if (!PyArg_ParseTuple(args,(char *)"O:_Matx_ushort_4_1___str__",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_ushort_4_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_ushort_4_1___str__" "', argument " "1"" of type '" "cv::Matx< ushort,4,1 > *""'");
}
arg1 = reinterpret_cast< cv::Matx< ushort,4,1 > * >(argp1);
result = cv_Matx_Sl_ushort_Sc_4_Sc_1_Sg____str__(arg1);
resultobj = SWIG_From_std_string(static_cast< std::string >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete__Matx_ushort_4_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< ushort,4,1 > *arg1 = (cv::Matx< ushort,4,1 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete__Matx_ushort_4_1",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_ushort_4_1_t, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__Matx_ushort_4_1" "', argument " "1"" of type '" "cv::Matx< ushort,4,1 > *""'");
}
arg1 = reinterpret_cast< cv::Matx< ushort,4,1 > * >(argp1);
delete arg1;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_Matx_ushort_4_1_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_cv__MatxT_ushort_4_1_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_new__Vec_ushort_4__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
ushort *arg1 = (ushort *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
cv::Vec< ushort,4 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__Vec_ushort_4",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ushort, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Vec_ushort_4" "', argument " "1"" of type '" "ushort const *""'");
}
arg1 = reinterpret_cast< ushort * >(argp1);
result = (cv::Vec< ushort,4 > *)new cv::Vec< ushort,4 >((ushort const *)arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__VecT_ushort_4_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Vec_ushort_4__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Vec< ushort,4 > *arg1 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
cv::Vec< ushort,4 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__Vec_ushort_4",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__VecT_ushort_4_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Vec_ushort_4" "', argument " "1"" of type '" "cv::Vec< ushort,4 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_ushort_4" "', argument " "1"" of type '" "cv::Vec< ushort,4 > const &""'");
}
arg1 = reinterpret_cast< cv::Vec< ushort,4 > * >(argp1);
result = (cv::Vec< ushort,4 > *)new cv::Vec< ushort,4 >((cv::Vec< ushort,4 > const &)*arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__VecT_ushort_4_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Vec_ushort_4_all(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
ushort arg1 ;
void *argp1 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
SwigValueWrapper< cv::Vec< ushort,4 > > result;
if (!PyArg_ParseTuple(args,(char *)"O:_Vec_ushort_4_all",&obj0)) SWIG_fail;
{
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_ushort, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Vec_ushort_4_all" "', argument " "1"" of type '" "ushort""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Vec_ushort_4_all" "', argument " "1"" of type '" "ushort""'");
} else {
ushort * temp = reinterpret_cast< ushort * >(argp1);
arg1 = *temp;
if (SWIG_IsNewObj(res1)) delete temp;
}
}
result = cv::Vec< ushort,4 >::SWIGTEMPLATEDISAMBIGUATOR all(arg1);
resultobj = SWIG_NewPointerObj((new cv::Vec< ushort,4 >(static_cast< const cv::Vec< ushort,4 >& >(result))), SWIGTYPE_p_cv__VecT_ushort_4_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Vec_ushort_4_mul(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Vec< ushort,4 > *arg1 = (cv::Vec< ushort,4 > *) 0 ;
cv::Vec< ushort,4 > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
SwigValueWrapper< cv::Vec< ushort,4 > > result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Vec_ushort_4_mul",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__VecT_ushort_4_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Vec_ushort_4_mul" "', argument " "1"" of type '" "cv::Vec< ushort,4 > const *""'");
}
arg1 = reinterpret_cast< cv::Vec< ushort,4 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__VecT_ushort_4_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Vec_ushort_4_mul" "', argument " "2"" of type '" "cv::Vec< ushort,4 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Vec_ushort_4_mul" "', argument " "2"" of type '" "cv::Vec< ushort,4 > const &""'");
}
arg2 = reinterpret_cast< cv::Vec< ushort,4 > * >(argp2);
result = ((cv::Vec< ushort,4 > const *)arg1)->mul((cv::Vec< ushort,4 > const &)*arg2);
resultobj = SWIG_NewPointerObj((new cv::Vec< ushort,4 >(static_cast< const cv::Vec< ushort,4 >& >(result))), SWIGTYPE_p_cv__VecT_ushort_4_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Vec_ushort_4___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Vec< ushort,4 > *arg1 = (cv::Vec< ushort,4 > *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
ushort *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:_Vec_ushort_4___call__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__VecT_ushort_4_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Vec_ushort_4___call__" "', argument " "1"" of type '" "cv::Vec< ushort,4 > const *""'");
}
arg1 = reinterpret_cast< cv::Vec< ushort,4 > * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_Vec_ushort_4___call__" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
result = (ushort *) &((cv::Vec< ushort,4 > const *)arg1)->operator ()(arg2);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ushort, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Vec_ushort_4__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< ushort,4,1 > *arg1 = 0 ;
cv::Matx< ushort,4,1 > *arg2 = 0 ;
cv::Matx_AddOp 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 ;
cv::Vec< ushort,4 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Vec_ushort_4",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_ushort_4_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Vec_ushort_4" "', argument " "1"" of type '" "cv::Matx< ushort,4,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_ushort_4" "', argument " "1"" of type '" "cv::Matx< ushort,4,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< ushort,4,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_ushort_4_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Vec_ushort_4" "', argument " "2"" of type '" "cv::Matx< ushort,4,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_ushort_4" "', argument " "2"" of type '" "cv::Matx< ushort,4,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< ushort,4,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_AddOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Vec_ushort_4" "', argument " "3"" of type '" "cv::Matx_AddOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_ushort_4" "', argument " "3"" of type '" "cv::Matx_AddOp""'");
} else {
cv::Matx_AddOp * temp = reinterpret_cast< cv::Matx_AddOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Vec< ushort,4 > *)new cv::Vec< ushort,4 >((cv::Matx< ushort,4,1 > const &)*arg1,(cv::Matx< ushort,4,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__VecT_ushort_4_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Vec_ushort_4__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< ushort,4,1 > *arg1 = 0 ;
cv::Matx< ushort,4,1 > *arg2 = 0 ;
cv::Matx_SubOp 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 ;
cv::Vec< ushort,4 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Vec_ushort_4",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_ushort_4_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Vec_ushort_4" "', argument " "1"" of type '" "cv::Matx< ushort,4,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_ushort_4" "', argument " "1"" of type '" "cv::Matx< ushort,4,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< ushort,4,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_ushort_4_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Vec_ushort_4" "', argument " "2"" of type '" "cv::Matx< ushort,4,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_ushort_4" "', argument " "2"" of type '" "cv::Matx< ushort,4,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< ushort,4,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_SubOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Vec_ushort_4" "', argument " "3"" of type '" "cv::Matx_SubOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_ushort_4" "', argument " "3"" of type '" "cv::Matx_SubOp""'");
} else {
cv::Matx_SubOp * temp = reinterpret_cast< cv::Matx_SubOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Vec< ushort,4 > *)new cv::Vec< ushort,4 >((cv::Matx< ushort,4,1 > const &)*arg1,(cv::Matx< ushort,4,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__VecT_ushort_4_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Vec_ushort_4__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< cv::Vec< ushort,4 >::value_type,std::allocator< cv::Vec< ushort,4 >::value_type > > arg1 ;
PyObject * obj0 = 0 ;
cv::Vec< ushort,4 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__Vec_ushort_4",&obj0)) SWIG_fail;
{
std::vector< ushort,std::allocator< ushort > > *ptr = (std::vector< ushort,std::allocator< ushort > > *)0;
int res = swig::asptr(obj0, &ptr);
if (!SWIG_IsOK(res) || !ptr) {
SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new__Vec_ushort_4" "', argument " "1"" of type '" "std::vector< cv::Vec< ushort,4 >::value_type,std::allocator< cv::Vec< ushort,4 >::value_type > >""'");
}
arg1 = *ptr;
if (SWIG_IsNewObj(res)) delete ptr;
}
result = (cv::Vec< ushort,4 > *)new_cv_Vec_Sl_ushort_Sc_4_Sg___SWIG_4(arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__VecT_ushort_4_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Vec_ushort_4(PyObject *self, PyObject *args) {
Py_ssize_t argc;
PyObject *argv[4] = {
0
};
Py_ssize_t ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = args ? PyObject_Length(args) : 0;
for (ii = 0; (ii < 3) && (ii < argc); 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_ushort, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Vec_ushort_4__SWIG_0(self, args);
}
}
if (argc == 1) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__VecT_ushort_4_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Vec_ushort_4__SWIG_1(self, args);
}
}
if (argc == 1) {
int _v;
int res = swig::asptr(argv[0], (std::vector< ushort,std::allocator< ushort > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Vec_ushort_4__SWIG_4(self, args);
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_ushort_4_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_ushort_4_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_SubOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Vec_ushort_4__SWIG_3(self, args);
}
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_ushort_4_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_ushort_4_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_AddOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Vec_ushort_4__SWIG_2(self, args);
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new__Vec_ushort_4'.\n"
" Possible C/C++ prototypes are:\n"
" cv::Vec< ushort,4 >::Vec(ushort const *)\n"
" cv::Vec< ushort,4 >::Vec(cv::Vec< ushort,4 > const &)\n"
" cv::Vec< ushort,4 >::Vec(cv::Matx< ushort,4,1 > const &,cv::Matx< ushort,4,1 > const &,cv::Matx_AddOp)\n"
" cv::Vec< ushort,4 >::Vec(cv::Matx< ushort,4,1 > const &,cv::Matx< ushort,4,1 > const &,cv::Matx_SubOp)\n"
" cv::Vec< ushort,4 >::Vec(std::vector< cv::Vec< ushort,4 >::value_type,std::allocator< cv::Vec< ushort,4 >::value_type > >)\n");
return 0;
}
SWIGINTERN PyObject *_wrap__Vec_ushort_4___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Vec< ushort,4 > *arg1 = (cv::Vec< ushort,4 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
std::string result;
if (!PyArg_ParseTuple(args,(char *)"O:_Vec_ushort_4___str__",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__VecT_ushort_4_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Vec_ushort_4___str__" "', argument " "1"" of type '" "cv::Vec< ushort,4 > *""'");
}
arg1 = reinterpret_cast< cv::Vec< ushort,4 > * >(argp1);
result = cv_Vec_Sl_ushort_Sc_4_Sg____str__(arg1);
resultobj = SWIG_From_std_string(static_cast< std::string >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete__Vec_ushort_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Vec< ushort,4 > *arg1 = (cv::Vec< ushort,4 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete__Vec_ushort_4",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__VecT_ushort_4_t, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__Vec_ushort_4" "', argument " "1"" of type '" "cv::Vec< ushort,4 > *""'");
}
arg1 = reinterpret_cast< cv::Vec< ushort,4 > * >(argp1);
delete arg1;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_Vec_ushort_4_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_cv__VecT_ushort_4_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_new__DataType_Vec_ushort_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::DataType< cv::Vec< ushort,4 > > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new__DataType_Vec_ushort_4")) SWIG_fail;
result = (cv::DataType< cv::Vec< ushort,4 > > *)new cv::DataType< cv::Vec< ushort,4 > >();
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__DataTypeT_cv__VecT_ushort_4_t_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete__DataType_Vec_ushort_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::DataType< cv::Vec< ushort,4 > > *arg1 = (cv::DataType< cv::Vec< ushort,4 > > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete__DataType_Vec_ushort_4",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__DataTypeT_cv__VecT_ushort_4_t_t, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__DataType_Vec_ushort_4" "', argument " "1"" of type '" "cv::DataType< cv::Vec< ushort,4 > > *""'");
}
arg1 = reinterpret_cast< cv::DataType< cv::Vec< ushort,4 > > * >(argp1);
delete arg1;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_DataType_Vec_ushort_4_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_cv__DataTypeT_cv__VecT_ushort_4_t_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_new__cv_numpy_sizeof_int(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::_SizeOf< int > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new__cv_numpy_sizeof_int")) SWIG_fail;
result = (cv::_SizeOf< int > *)new cv::_SizeOf< int >();
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv___SizeOfT_int_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete__cv_numpy_sizeof_int(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::_SizeOf< int > *arg1 = (cv::_SizeOf< int > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete__cv_numpy_sizeof_int",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv___SizeOfT_int_t, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__cv_numpy_sizeof_int" "', argument " "1"" of type '" "cv::_SizeOf< int > *""'");
}
arg1 = reinterpret_cast< cv::_SizeOf< int > * >(argp1);
delete arg1;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_cv_numpy_sizeof_int_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_cv___SizeOfT_int_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap__intArray_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< int > *arg1 = (std::vector< int > *) 0 ;
PyObject **arg2 = (PyObject **) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
swig::SwigPyIterator *result = 0 ;
arg2 = &obj0;
if (!PyArg_ParseTuple(args,(char *)"O:_intArray_iterator",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_intArray_iterator" "', argument " "1"" of type '" "std::vector< int > *""'");
}
arg1 = reinterpret_cast< std::vector< int > * >(argp1);
result = (swig::SwigPyIterator *)std_vector_Sl_int_Sg__iterator(arg1,arg2);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__intArray___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< int > *arg1 = (std::vector< int > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
bool result;
if (!PyArg_ParseTuple(args,(char *)"O:_intArray___nonzero__",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_intArray___nonzero__" "', argument " "1"" of type '" "std::vector< int > const *""'");
}
arg1 = reinterpret_cast< std::vector< int > * >(argp1);
result = (bool)std_vector_Sl_int_Sg____nonzero__((std::vector< int > const *)arg1);
resultobj = SWIG_From_bool(static_cast< bool >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__intArray___bool__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< int > *arg1 = (std::vector< int > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
bool result;
if (!PyArg_ParseTuple(args,(char *)"O:_intArray___bool__",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_intArray___bool__" "', argument " "1"" of type '" "std::vector< int > const *""'");
}
arg1 = reinterpret_cast< std::vector< int > * >(argp1);
result = (bool)std_vector_Sl_int_Sg____bool__((std::vector< int > const *)arg1);
resultobj = SWIG_From_bool(static_cast< bool >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__intArray___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< int > *arg1 = (std::vector< int > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
std::vector< int >::size_type result;
if (!PyArg_ParseTuple(args,(char *)"O:_intArray___len__",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_intArray___len__" "', argument " "1"" of type '" "std::vector< int > const *""'");
}
arg1 = reinterpret_cast< std::vector< int > * >(argp1);
result = std_vector_Sl_int_Sg____len__((std::vector< int > const *)arg1);
resultobj = SWIG_From_size_t(static_cast< size_t >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__intArray___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< int > *arg1 = (std::vector< int > *) 0 ;
std::vector< int >::difference_type arg2 ;
std::vector< int >::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< int,std::allocator< int > > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:_intArray___getslice__",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_intArray___getslice__" "', argument " "1"" of type '" "std::vector< int > *""'");
}
arg1 = reinterpret_cast< std::vector< int > * >(argp1);
ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_intArray___getslice__" "', argument " "2"" of type '" "std::vector< int >::difference_type""'");
}
arg2 = static_cast< std::vector< int >::difference_type >(val2);
ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "_intArray___getslice__" "', argument " "3"" of type '" "std::vector< int >::difference_type""'");
}
arg3 = static_cast< std::vector< int >::difference_type >(val3);
try {
result = (std::vector< int,std::allocator< int > > *)std_vector_Sl_int_Sg____getslice__(arg1,arg2,arg3);
}
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_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__intArray___setslice____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< int > *arg1 = (std::vector< int > *) 0 ;
std::vector< int >::difference_type arg2 ;
std::vector< int >::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:_intArray___setslice__",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_intArray___setslice__" "', argument " "1"" of type '" "std::vector< int > *""'");
}
arg1 = reinterpret_cast< std::vector< int > * >(argp1);
ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_intArray___setslice__" "', argument " "2"" of type '" "std::vector< int >::difference_type""'");
}
arg2 = static_cast< std::vector< int >::difference_type >(val2);
ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "_intArray___setslice__" "', argument " "3"" of type '" "std::vector< int >::difference_type""'");
}
arg3 = static_cast< std::vector< int >::difference_type >(val3);
try {
std_vector_Sl_int_Sg____setslice____SWIG_0(arg1,arg2,arg3);
}
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();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__intArray___setslice____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< int > *arg1 = (std::vector< int > *) 0 ;
std::vector< int >::difference_type arg2 ;
std::vector< int >::difference_type arg3 ;
std::vector< int,std::allocator< int > > *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:_intArray___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_intArray___setslice__" "', argument " "1"" of type '" "std::vector< int > *""'");
}
arg1 = reinterpret_cast< std::vector< int > * >(argp1);
ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_intArray___setslice__" "', argument " "2"" of type '" "std::vector< int >::difference_type""'");
}
arg2 = static_cast< std::vector< int >::difference_type >(val2);
ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "_intArray___setslice__" "', argument " "3"" of type '" "std::vector< int >::difference_type""'");
}
arg3 = static_cast< std::vector< int >::difference_type >(val3);
{
std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
res4 = swig::asptr(obj3, &ptr);
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "_intArray___setslice__" "', argument " "4"" of type '" "std::vector< int,std::allocator< int > > const &""'");
}
if (!ptr) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_intArray___setslice__" "', argument " "4"" of type '" "std::vector< int,std::allocator< int > > const &""'");
}
arg4 = ptr;
}
try {
std_vector_Sl_int_Sg____setslice____SWIG_1(arg1,arg2,arg3,(std::vector< int,std::allocator< int > > 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__intArray___setslice__(PyObject *self, PyObject *args) {
Py_ssize_t argc;
PyObject *argv[5] = {
0
};
Py_ssize_t ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = args ? PyObject_Length(args) : 0;
for (ii = 0; (ii < 4) && (ii < argc); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 3) {
int _v;
int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap__intArray___setslice____SWIG_0(self, args);
}
}
}
}
if (argc == 4) {
int _v;
int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
int res = swig::asptr(argv[3], (std::vector< int,std::allocator< int > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
return _wrap__intArray___setslice____SWIG_1(self, args);
}
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function '_intArray___setslice__'.\n"
" Possible C/C++ prototypes are:\n"
" std::vector< int >::__setslice__(std::vector< int >::difference_type,std::vector< int >::difference_type)\n"
" std::vector< int >::__setslice__(std::vector< int >::difference_type,std::vector< int >::difference_type,std::vector< int,std::allocator< int > > const &)\n");
return 0;
}
SWIGINTERN PyObject *_wrap__intArray___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< int > *arg1 = (std::vector< int > *) 0 ;
std::vector< int >::difference_type arg2 ;
std::vector< int >::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:_intArray___delslice__",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_intArray___delslice__" "', argument " "1"" of type '" "std::vector< int > *""'");
}
arg1 = reinterpret_cast< std::vector< int > * >(argp1);
ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_intArray___delslice__" "', argument " "2"" of type '" "std::vector< int >::difference_type""'");
}
arg2 = static_cast< std::vector< int >::difference_type >(val2);
ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "_intArray___delslice__" "', argument " "3"" of type '" "std::vector< int >::difference_type""'");
}
arg3 = static_cast< std::vector< int >::difference_type >(val3);
try {
std_vector_Sl_int_Sg____delslice__(arg1,arg2,arg3);
}
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();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__intArray___delitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< int > *arg1 = (std::vector< int > *) 0 ;
std::vector< int >::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:_intArray___delitem__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_intArray___delitem__" "', argument " "1"" of type '" "std::vector< int > *""'");
}
arg1 = reinterpret_cast< std::vector< int > * >(argp1);
ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_intArray___delitem__" "', argument " "2"" of type '" "std::vector< int >::difference_type""'");
}
arg2 = static_cast< std::vector< int >::difference_type >(val2);
try {
std_vector_Sl_int_Sg____delitem____SWIG_0(arg1,arg2);
}
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();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__intArray___getitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< int > *arg1 = (std::vector< int > *) 0 ;
PySliceObject *arg2 = (PySliceObject *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
std::vector< int,std::allocator< int > > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:_intArray___getitem__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_intArray___getitem__" "', argument " "1"" of type '" "std::vector< int > *""'");
}
arg1 = reinterpret_cast< std::vector< int > * >(argp1);
{
if (!PySlice_Check(obj1)) {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "_intArray___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
arg2 = (PySliceObject *) obj1;
}
try {
result = (std::vector< int,std::allocator< int > > *)std_vector_Sl_int_Sg____getitem____SWIG_0(arg1,arg2);
}
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_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__intArray___setitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< int > *arg1 = (std::vector< int > *) 0 ;
PySliceObject *arg2 = (PySliceObject *) 0 ;
std::vector< int,std::allocator< int > > *arg3 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res3 = SWIG_OLDOBJ ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:_intArray___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_intArray___setitem__" "', argument " "1"" of type '" "std::vector< int > *""'");
}
arg1 = reinterpret_cast< std::vector< int > * >(argp1);
{
if (!PySlice_Check(obj1)) {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "_intArray___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
arg2 = (PySliceObject *) obj1;
}
{
std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
res3 = swig::asptr(obj2, &ptr);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "_intArray___setitem__" "', argument " "3"" of type '" "std::vector< int,std::allocator< int > > const &""'");
}
if (!ptr) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_intArray___setitem__" "', argument " "3"" of type '" "std::vector< int,std::allocator< int > > const &""'");
}
arg3 = ptr;
}
try {
std_vector_Sl_int_Sg____setitem____SWIG_0(arg1,arg2,(std::vector< int,std::allocator< int > > const &)*arg3);
}
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(res3)) delete arg3;
return resultobj;
fail:
if (SWIG_IsNewObj(res3)) delete arg3;
return NULL;
}
SWIGINTERN PyObject *_wrap__intArray___setitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< int > *arg1 = (std::vector< int > *) 0 ;
PySliceObject *arg2 = (PySliceObject *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:_intArray___setitem__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_intArray___setitem__" "', argument " "1"" of type '" "std::vector< int > *""'");
}
arg1 = reinterpret_cast< std::vector< int > * >(argp1);
{
if (!PySlice_Check(obj1)) {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "_intArray___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
arg2 = (PySliceObject *) obj1;
}
try {
std_vector_Sl_int_Sg____setitem____SWIG_1(arg1,arg2);
}
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();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__intArray___delitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< int > *arg1 = (std::vector< int > *) 0 ;
PySliceObject *arg2 = (PySliceObject *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:_intArray___delitem__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_intArray___delitem__" "', argument " "1"" of type '" "std::vector< int > *""'");
}
arg1 = reinterpret_cast< std::vector< int > * >(argp1);
{
if (!PySlice_Check(obj1)) {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "_intArray___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
arg2 = (PySliceObject *) obj1;
}
try {
std_vector_Sl_int_Sg____delitem____SWIG_1(arg1,arg2);
}
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();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__intArray___delitem__(PyObject *self, PyObject *args) {
Py_ssize_t argc;
PyObject *argv[3] = {
0
};
Py_ssize_t ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = args ? PyObject_Length(args) : 0;
for (ii = 0; (ii < 2) && (ii < argc); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 2) {
int _v;
int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
{
_v = PySlice_Check(argv[1]);
}
if (_v) {
return _wrap__intArray___delitem____SWIG_1(self, args);
}
}
}
if (argc == 2) {
int _v;
int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap__intArray___delitem____SWIG_0(self, args);
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function '_intArray___delitem__'.\n"
" Possible C/C++ prototypes are:\n"
" std::vector< int >::__delitem__(std::vector< int >::difference_type)\n"
" std::vector< int >::__delitem__(PySliceObject *)\n");
return 0;
}
SWIGINTERN PyObject *_wrap__intArray___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< int > *arg1 = (std::vector< int > *) 0 ;
std::vector< int >::difference_type arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
ptrdiff_t val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
std::vector< int >::value_type *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:_intArray___getitem__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_intArray___getitem__" "', argument " "1"" of type '" "std::vector< int > const *""'");
}
arg1 = reinterpret_cast< std::vector< int > * >(argp1);
ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_intArray___getitem__" "', argument " "2"" of type '" "std::vector< int >::difference_type""'");
}
arg2 = static_cast< std::vector< int >::difference_type >(val2);
try {
result = (std::vector< int >::value_type *) &std_vector_Sl_int_Sg____getitem____SWIG_1((std::vector< int > const *)arg1,arg2);
}
catch(std::out_of_range &_e) {
SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
}
resultobj = SWIG_From_int(static_cast< int >(*result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__intArray___getitem__(PyObject *self, PyObject *args) {
Py_ssize_t argc;
PyObject *argv[3] = {
0
};
Py_ssize_t ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = args ? PyObject_Length(args) : 0;
for (ii = 0; (ii < 2) && (ii < argc); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 2) {
int _v;
int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
{
_v = PySlice_Check(argv[1]);
}
if (_v) {
return _wrap__intArray___getitem____SWIG_0(self, args);
}
}
}
if (argc == 2) {
int _v;
int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap__intArray___getitem____SWIG_1(self, args);
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function '_intArray___getitem__'.\n"
" Possible C/C++ prototypes are:\n"
" std::vector< int >::__getitem__(PySliceObject *)\n"
" std::vector< int >::__getitem__(std::vector< int >::difference_type) const\n");
return 0;
}
SWIGINTERN PyObject *_wrap__intArray___setitem____SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< int > *arg1 = (std::vector< int > *) 0 ;
std::vector< int >::difference_type arg2 ;
std::vector< int >::value_type *arg3 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
ptrdiff_t val2 ;
int ecode2 = 0 ;
std::vector< int >::value_type temp3 ;
int val3 ;
int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:_intArray___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_intArray___setitem__" "', argument " "1"" of type '" "std::vector< int > *""'");
}
arg1 = reinterpret_cast< std::vector< int > * >(argp1);
ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_intArray___setitem__" "', argument " "2"" of type '" "std::vector< int >::difference_type""'");
}
arg2 = static_cast< std::vector< int >::difference_type >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "_intArray___setitem__" "', argument " "3"" of type '" "std::vector< int >::value_type""'");
}
temp3 = static_cast< std::vector< int >::value_type >(val3);
arg3 = &temp3;
try {
std_vector_Sl_int_Sg____setitem____SWIG_2(arg1,arg2,(int 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__intArray___setitem__(PyObject *self, PyObject *args) {
Py_ssize_t argc;
PyObject *argv[4] = {
0
};
Py_ssize_t ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = args ? PyObject_Length(args) : 0;
for (ii = 0; (ii < 3) && (ii < argc); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 2) {
int _v;
int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
{
_v = PySlice_Check(argv[1]);
}
if (_v) {
return _wrap__intArray___setitem____SWIG_1(self, args);
}
}
}
if (argc == 3) {
int _v;
int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
{
_v = PySlice_Check(argv[1]);
}
if (_v) {
int res = swig::asptr(argv[2], (std::vector< int,std::allocator< int > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
return _wrap__intArray___setitem____SWIG_0(self, args);
}
}
}
}
if (argc == 3) {
int _v;
int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_ptrdiff_t(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__intArray___setitem____SWIG_2(self, args);
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function '_intArray___setitem__'.\n"
" Possible C/C++ prototypes are:\n"
" std::vector< int >::__setitem__(PySliceObject *,std::vector< int,std::allocator< int > > const &)\n"
" std::vector< int >::__setitem__(PySliceObject *)\n"
" std::vector< int >::__setitem__(std::vector< int >::difference_type,std::vector< int >::value_type const &)\n");
return 0;
}
SWIGINTERN PyObject *_wrap__intArray_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< int > *arg1 = (std::vector< int > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
std::vector< int >::value_type result;
if (!PyArg_ParseTuple(args,(char *)"O:_intArray_pop",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_intArray_pop" "', argument " "1"" of type '" "std::vector< int > *""'");
}
arg1 = reinterpret_cast< std::vector< int > * >(argp1);
try {
result = (std::vector< int >::value_type)std_vector_Sl_int_Sg__pop(arg1);
}
catch(std::out_of_range &_e) {
SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
}
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__intArray_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< int > *arg1 = (std::vector< int > *) 0 ;
std::vector< int >::value_type *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
std::vector< int >::value_type temp2 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:_intArray_append",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_intArray_append" "', argument " "1"" of type '" "std::vector< int > *""'");
}
arg1 = reinterpret_cast< std::vector< int > * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_intArray_append" "', argument " "2"" of type '" "std::vector< int >::value_type""'");
}
temp2 = static_cast< std::vector< int >::value_type >(val2);
arg2 = &temp2;
std_vector_Sl_int_Sg__append(arg1,(int const &)*arg2);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__intArray__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< int > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new__intArray")) SWIG_fail;
result = (std::vector< int > *)new std::vector< int >();
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__intArray__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< int > *arg1 = 0 ;
int res1 = SWIG_OLDOBJ ;
PyObject * obj0 = 0 ;
std::vector< int > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__intArray",&obj0)) SWIG_fail;
{
std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
res1 = swig::asptr(obj0, &ptr);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__intArray" "', argument " "1"" of type '" "std::vector< int > const &""'");
}
if (!ptr) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__intArray" "', argument " "1"" of type '" "std::vector< int > const &""'");
}
arg1 = ptr;
}
result = (std::vector< int > *)new std::vector< int >((std::vector< int > const &)*arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_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__intArray_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< int > *arg1 = (std::vector< int > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
bool result;
if (!PyArg_ParseTuple(args,(char *)"O:_intArray_empty",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_intArray_empty" "', argument " "1"" of type '" "std::vector< int > const *""'");
}
arg1 = reinterpret_cast< std::vector< int > * >(argp1);
result = (bool)((std::vector< int > const *)arg1)->empty();
resultobj = SWIG_From_bool(static_cast< bool >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__intArray_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< int > *arg1 = (std::vector< int > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
std::vector< int >::size_type result;
if (!PyArg_ParseTuple(args,(char *)"O:_intArray_size",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_intArray_size" "', argument " "1"" of type '" "std::vector< int > const *""'");
}
arg1 = reinterpret_cast< std::vector< int > * >(argp1);
result = ((std::vector< int > const *)arg1)->size();
resultobj = SWIG_From_size_t(static_cast< size_t >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__intArray_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< int > *arg1 = (std::vector< int > *) 0 ;
std::vector< int > *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:_intArray_swap",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_intArray_swap" "', argument " "1"" of type '" "std::vector< int > *""'");
}
arg1 = reinterpret_cast< std::vector< int > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_intArray_swap" "', argument " "2"" of type '" "std::vector< int > &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_intArray_swap" "', argument " "2"" of type '" "std::vector< int > &""'");
}
arg2 = reinterpret_cast< std::vector< int > * >(argp2);
(arg1)->swap(*arg2);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__intArray_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< int > *arg1 = (std::vector< int > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
std::vector< int >::iterator result;
if (!PyArg_ParseTuple(args,(char *)"O:_intArray_begin",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_intArray_begin" "', argument " "1"" of type '" "std::vector< int > *""'");
}
arg1 = reinterpret_cast< std::vector< int > * >(argp1);
result = (arg1)->begin();
resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< int >::iterator & >(result)),
swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__intArray_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< int > *arg1 = (std::vector< int > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
std::vector< int >::iterator result;
if (!PyArg_ParseTuple(args,(char *)"O:_intArray_end",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_intArray_end" "', argument " "1"" of type '" "std::vector< int > *""'");
}
arg1 = reinterpret_cast< std::vector< int > * >(argp1);
result = (arg1)->end();
resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< int >::iterator & >(result)),
swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__intArray_rbegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< int > *arg1 = (std::vector< int > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
std::vector< int >::reverse_iterator result;
if (!PyArg_ParseTuple(args,(char *)"O:_intArray_rbegin",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_intArray_rbegin" "', argument " "1"" of type '" "std::vector< int > *""'");
}
arg1 = reinterpret_cast< std::vector< int > * >(argp1);
result = (arg1)->rbegin();
resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< int >::reverse_iterator & >(result)),
swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__intArray_rend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< int > *arg1 = (std::vector< int > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
std::vector< int >::reverse_iterator result;
if (!PyArg_ParseTuple(args,(char *)"O:_intArray_rend",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_intArray_rend" "', argument " "1"" of type '" "std::vector< int > *""'");
}
arg1 = reinterpret_cast< std::vector< int > * >(argp1);
result = (arg1)->rend();
resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< int >::reverse_iterator & >(result)),
swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__intArray_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< int > *arg1 = (std::vector< int > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:_intArray_clear",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_intArray_clear" "', argument " "1"" of type '" "std::vector< int > *""'");
}
arg1 = reinterpret_cast< std::vector< int > * >(argp1);
(arg1)->clear();
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__intArray_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< int > *arg1 = (std::vector< int > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
SwigValueWrapper< std::allocator< int > > result;
if (!PyArg_ParseTuple(args,(char *)"O:_intArray_get_allocator",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_intArray_get_allocator" "', argument " "1"" of type '" "std::vector< int > const *""'");
}
arg1 = reinterpret_cast< std::vector< int > * >(argp1);
result = ((std::vector< int > const *)arg1)->get_allocator();
resultobj = SWIG_NewPointerObj((new std::vector< int >::allocator_type(static_cast< const std::vector< int >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_int_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__intArray__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< int >::size_type arg1 ;
size_t val1 ;
int ecode1 = 0 ;
PyObject * obj0 = 0 ;
std::vector< int > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__intArray",&obj0)) SWIG_fail;
ecode1 = SWIG_AsVal_size_t(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new__intArray" "', argument " "1"" of type '" "std::vector< int >::size_type""'");
}
arg1 = static_cast< std::vector< int >::size_type >(val1);
result = (std::vector< int > *)new std::vector< int >(arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__intArray_pop_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< int > *arg1 = (std::vector< int > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:_intArray_pop_back",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_intArray_pop_back" "', argument " "1"" of type '" "std::vector< int > *""'");
}
arg1 = reinterpret_cast< std::vector< int > * >(argp1);
(arg1)->pop_back();
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__intArray_resize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< int > *arg1 = (std::vector< int > *) 0 ;
std::vector< int >::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:_intArray_resize",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_intArray_resize" "', argument " "1"" of type '" "std::vector< int > *""'");
}
arg1 = reinterpret_cast< std::vector< int > * >(argp1);
ecode2 = SWIG_AsVal_size_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_intArray_resize" "', argument " "2"" of type '" "std::vector< int >::size_type""'");
}
arg2 = static_cast< std::vector< int >::size_type >(val2);
(arg1)->resize(arg2);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__intArray_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< int > *arg1 = (std::vector< int > *) 0 ;
std::vector< int >::iterator arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
swig::SwigPyIterator *iter2 = 0 ;
int res2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
std::vector< int >::iterator result;
if (!PyArg_ParseTuple(args,(char *)"OO:_intArray_erase",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_intArray_erase" "', argument " "1"" of type '" "std::vector< int > *""'");
}
arg1 = reinterpret_cast< std::vector< int > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
if (!SWIG_IsOK(res2) || !iter2) {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "_intArray_erase" "', argument " "2"" of type '" "std::vector< int >::iterator""'");
} else {
swig::SwigPyIterator_T<std::vector< int >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< int >::iterator > *>(iter2);
if (iter_t) {
arg2 = iter_t->get_current();
} else {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "_intArray_erase" "', argument " "2"" of type '" "std::vector< int >::iterator""'");
}
}
result = std_vector_Sl_int_Sg__erase__SWIG_0(arg1,arg2);
resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< int >::iterator & >(result)),
swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__intArray_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< int > *arg1 = (std::vector< int > *) 0 ;
std::vector< int >::iterator arg2 ;
std::vector< int >::iterator arg3 ;
void *argp1 = 0 ;
int res1 = 0 ;
swig::SwigPyIterator *iter2 = 0 ;
int res2 ;
swig::SwigPyIterator *iter3 = 0 ;
int res3 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
std::vector< int >::iterator result;
if (!PyArg_ParseTuple(args,(char *)"OOO:_intArray_erase",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_intArray_erase" "', argument " "1"" of type '" "std::vector< int > *""'");
}
arg1 = reinterpret_cast< std::vector< int > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
if (!SWIG_IsOK(res2) || !iter2) {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "_intArray_erase" "', argument " "2"" of type '" "std::vector< int >::iterator""'");
} else {
swig::SwigPyIterator_T<std::vector< int >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< int >::iterator > *>(iter2);
if (iter_t) {
arg2 = iter_t->get_current();
} else {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "_intArray_erase" "', argument " "2"" of type '" "std::vector< int >::iterator""'");
}
}
res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
if (!SWIG_IsOK(res3) || !iter3) {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "_intArray_erase" "', argument " "3"" of type '" "std::vector< int >::iterator""'");
} else {
swig::SwigPyIterator_T<std::vector< int >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< int >::iterator > *>(iter3);
if (iter_t) {
arg3 = iter_t->get_current();
} else {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "_intArray_erase" "', argument " "3"" of type '" "std::vector< int >::iterator""'");
}
}
result = std_vector_Sl_int_Sg__erase__SWIG_1(arg1,arg2,arg3);
resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< int >::iterator & >(result)),
swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__intArray_erase(PyObject *self, PyObject *args) {
Py_ssize_t argc;
PyObject *argv[4] = {
0
};
Py_ssize_t ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = args ? PyObject_Length(args) : 0;
for (ii = 0; (ii < 3) && (ii < argc); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 2) {
int _v;
int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
swig::SwigPyIterator *iter = 0;
int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
_v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< int >::iterator > *>(iter) != 0));
if (_v) {
return _wrap__intArray_erase__SWIG_0(self, args);
}
}
}
if (argc == 3) {
int _v;
int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
swig::SwigPyIterator *iter = 0;
int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
_v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< int >::iterator > *>(iter) != 0));
if (_v) {
swig::SwigPyIterator *iter = 0;
int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
_v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< int >::iterator > *>(iter) != 0));
if (_v) {
return _wrap__intArray_erase__SWIG_1(self, args);
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function '_intArray_erase'.\n"
" Possible C/C++ prototypes are:\n"
" std::vector< int >::erase(std::vector< int >::iterator)\n"
" std::vector< int >::erase(std::vector< int >::iterator,std::vector< int >::iterator)\n");
return 0;
}
SWIGINTERN PyObject *_wrap_new__intArray__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< int >::size_type arg1 ;
std::vector< int >::value_type *arg2 = 0 ;
size_t val1 ;
int ecode1 = 0 ;
std::vector< int >::value_type temp2 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
std::vector< int > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:new__intArray",&obj0,&obj1)) SWIG_fail;
ecode1 = SWIG_AsVal_size_t(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new__intArray" "', argument " "1"" of type '" "std::vector< int >::size_type""'");
}
arg1 = static_cast< std::vector< int >::size_type >(val1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new__intArray" "', argument " "2"" of type '" "std::vector< int >::value_type""'");
}
temp2 = static_cast< std::vector< int >::value_type >(val2);
arg2 = &temp2;
result = (std::vector< int > *)new std::vector< int >(arg1,(std::vector< int >::value_type const &)*arg2);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__intArray(PyObject *self, PyObject *args) {
Py_ssize_t argc;
PyObject *argv[3] = {
0
};
Py_ssize_t ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = args ? PyObject_Length(args) : 0;
for (ii = 0; (ii < 2) && (ii < argc); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 0) {
return _wrap_new__intArray__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__intArray__SWIG_2(self, args);
}
}
if (argc == 1) {
int _v;
int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__intArray__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_int(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_new__intArray__SWIG_3(self, args);
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new__intArray'.\n"
" Possible C/C++ prototypes are:\n"
" std::vector< int >::vector()\n"
" std::vector< int >::vector(std::vector< int > const &)\n"
" std::vector< int >::vector(std::vector< int >::size_type)\n"
" std::vector< int >::vector(std::vector< int >::size_type,std::vector< int >::value_type const &)\n");
return 0;
}
SWIGINTERN PyObject *_wrap__intArray_push_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< int > *arg1 = (std::vector< int > *) 0 ;
std::vector< int >::value_type *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
std::vector< int >::value_type temp2 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:_intArray_push_back",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_intArray_push_back" "', argument " "1"" of type '" "std::vector< int > *""'");
}
arg1 = reinterpret_cast< std::vector< int > * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_intArray_push_back" "', argument " "2"" of type '" "std::vector< int >::value_type""'");
}
temp2 = static_cast< std::vector< int >::value_type >(val2);
arg2 = &temp2;
(arg1)->push_back((std::vector< int >::value_type const &)*arg2);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__intArray_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< int > *arg1 = (std::vector< int > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
std::vector< int >::value_type *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:_intArray_front",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_intArray_front" "', argument " "1"" of type '" "std::vector< int > const *""'");
}
arg1 = reinterpret_cast< std::vector< int > * >(argp1);
result = (std::vector< int >::value_type *) &((std::vector< int > const *)arg1)->front();
resultobj = SWIG_From_int(static_cast< int >(*result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__intArray_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< int > *arg1 = (std::vector< int > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
std::vector< int >::value_type *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:_intArray_back",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_intArray_back" "', argument " "1"" of type '" "std::vector< int > const *""'");
}
arg1 = reinterpret_cast< std::vector< int > * >(argp1);
result = (std::vector< int >::value_type *) &((std::vector< int > const *)arg1)->back();
resultobj = SWIG_From_int(static_cast< int >(*result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__intArray_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< int > *arg1 = (std::vector< int > *) 0 ;
std::vector< int >::size_type arg2 ;
std::vector< int >::value_type *arg3 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
size_t val2 ;
int ecode2 = 0 ;
std::vector< int >::value_type temp3 ;
int val3 ;
int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:_intArray_assign",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_intArray_assign" "', argument " "1"" of type '" "std::vector< int > *""'");
}
arg1 = reinterpret_cast< std::vector< int > * >(argp1);
ecode2 = SWIG_AsVal_size_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_intArray_assign" "', argument " "2"" of type '" "std::vector< int >::size_type""'");
}
arg2 = static_cast< std::vector< int >::size_type >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "_intArray_assign" "', argument " "3"" of type '" "std::vector< int >::value_type""'");
}
temp3 = static_cast< std::vector< int >::value_type >(val3);
arg3 = &temp3;
(arg1)->assign(arg2,(std::vector< int >::value_type const &)*arg3);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__intArray_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< int > *arg1 = (std::vector< int > *) 0 ;
std::vector< int >::size_type arg2 ;
std::vector< int >::value_type *arg3 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
size_t val2 ;
int ecode2 = 0 ;
std::vector< int >::value_type temp3 ;
int val3 ;
int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:_intArray_resize",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_intArray_resize" "', argument " "1"" of type '" "std::vector< int > *""'");
}
arg1 = reinterpret_cast< std::vector< int > * >(argp1);
ecode2 = SWIG_AsVal_size_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_intArray_resize" "', argument " "2"" of type '" "std::vector< int >::size_type""'");
}
arg2 = static_cast< std::vector< int >::size_type >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "_intArray_resize" "', argument " "3"" of type '" "std::vector< int >::value_type""'");
}
temp3 = static_cast< std::vector< int >::value_type >(val3);
arg3 = &temp3;
(arg1)->resize(arg2,(std::vector< int >::value_type const &)*arg3);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__intArray_resize(PyObject *self, PyObject *args) {
Py_ssize_t argc;
PyObject *argv[4] = {
0
};
Py_ssize_t ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = args ? PyObject_Length(args) : 0;
for (ii = 0; (ii < 3) && (ii < argc); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 2) {
int _v;
int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_size_t(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap__intArray_resize__SWIG_0(self, args);
}
}
}
if (argc == 3) {
int _v;
int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(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_int(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap__intArray_resize__SWIG_1(self, args);
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function '_intArray_resize'.\n"
" Possible C/C++ prototypes are:\n"
" std::vector< int >::resize(std::vector< int >::size_type)\n"
" std::vector< int >::resize(std::vector< int >::size_type,std::vector< int >::value_type const &)\n");
return 0;
}
SWIGINTERN PyObject *_wrap__intArray_insert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< int > *arg1 = (std::vector< int > *) 0 ;
std::vector< int >::iterator arg2 ;
std::vector< int >::value_type *arg3 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
swig::SwigPyIterator *iter2 = 0 ;
int res2 ;
std::vector< int >::value_type temp3 ;
int val3 ;
int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
std::vector< int >::iterator result;
if (!PyArg_ParseTuple(args,(char *)"OOO:_intArray_insert",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_intArray_insert" "', argument " "1"" of type '" "std::vector< int > *""'");
}
arg1 = reinterpret_cast< std::vector< int > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
if (!SWIG_IsOK(res2) || !iter2) {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "_intArray_insert" "', argument " "2"" of type '" "std::vector< int >::iterator""'");
} else {
swig::SwigPyIterator_T<std::vector< int >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< int >::iterator > *>(iter2);
if (iter_t) {
arg2 = iter_t->get_current();
} else {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "_intArray_insert" "', argument " "2"" of type '" "std::vector< int >::iterator""'");
}
}
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "_intArray_insert" "', argument " "3"" of type '" "std::vector< int >::value_type""'");
}
temp3 = static_cast< std::vector< int >::value_type >(val3);
arg3 = &temp3;
result = std_vector_Sl_int_Sg__insert__SWIG_0(arg1,arg2,(int const &)*arg3);
resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< int >::iterator & >(result)),
swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__intArray_insert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< int > *arg1 = (std::vector< int > *) 0 ;
std::vector< int >::iterator arg2 ;
std::vector< int >::size_type arg3 ;
std::vector< int >::value_type *arg4 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
swig::SwigPyIterator *iter2 = 0 ;
int res2 ;
size_t val3 ;
int ecode3 = 0 ;
std::vector< int >::value_type temp4 ;
int val4 ;
int ecode4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOO:_intArray_insert",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_intArray_insert" "', argument " "1"" of type '" "std::vector< int > *""'");
}
arg1 = reinterpret_cast< std::vector< int > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
if (!SWIG_IsOK(res2) || !iter2) {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "_intArray_insert" "', argument " "2"" of type '" "std::vector< int >::iterator""'");
} else {
swig::SwigPyIterator_T<std::vector< int >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< int >::iterator > *>(iter2);
if (iter_t) {
arg2 = iter_t->get_current();
} else {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "_intArray_insert" "', argument " "2"" of type '" "std::vector< int >::iterator""'");
}
}
ecode3 = SWIG_AsVal_size_t(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "_intArray_insert" "', argument " "3"" of type '" "std::vector< int >::size_type""'");
}
arg3 = static_cast< std::vector< int >::size_type >(val3);
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "_intArray_insert" "', argument " "4"" of type '" "std::vector< int >::value_type""'");
}
temp4 = static_cast< std::vector< int >::value_type >(val4);
arg4 = &temp4;
std_vector_Sl_int_Sg__insert__SWIG_1(arg1,arg2,arg3,(int const &)*arg4);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__intArray_insert(PyObject *self, PyObject *args) {
Py_ssize_t argc;
PyObject *argv[5] = {
0
};
Py_ssize_t ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = args ? PyObject_Length(args) : 0;
for (ii = 0; (ii < 4) && (ii < argc); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 3) {
int _v;
int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
swig::SwigPyIterator *iter = 0;
int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
_v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< int >::iterator > *>(iter) != 0));
if (_v) {
{
int res = SWIG_AsVal_int(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap__intArray_insert__SWIG_0(self, args);
}
}
}
}
if (argc == 4) {
int _v;
int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
swig::SwigPyIterator *iter = 0;
int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
_v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< int >::iterator > *>(iter) != 0));
if (_v) {
{
int res = SWIG_AsVal_size_t(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__intArray_insert__SWIG_1(self, args);
}
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function '_intArray_insert'.\n"
" Possible C/C++ prototypes are:\n"
" std::vector< int >::insert(std::vector< int >::iterator,std::vector< int >::value_type const &)\n"
" std::vector< int >::insert(std::vector< int >::iterator,std::vector< int >::size_type,std::vector< int >::value_type const &)\n");
return 0;
}
SWIGINTERN PyObject *_wrap__intArray_reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< int > *arg1 = (std::vector< int > *) 0 ;
std::vector< int >::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:_intArray_reserve",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_intArray_reserve" "', argument " "1"" of type '" "std::vector< int > *""'");
}
arg1 = reinterpret_cast< std::vector< int > * >(argp1);
ecode2 = SWIG_AsVal_size_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_intArray_reserve" "', argument " "2"" of type '" "std::vector< int >::size_type""'");
}
arg2 = static_cast< std::vector< int >::size_type >(val2);
(arg1)->reserve(arg2);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__intArray_capacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< int > *arg1 = (std::vector< int > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
std::vector< int >::size_type result;
if (!PyArg_ParseTuple(args,(char *)"O:_intArray_capacity",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_intArray_capacity" "', argument " "1"" of type '" "std::vector< int > const *""'");
}
arg1 = reinterpret_cast< std::vector< int > * >(argp1);
result = ((std::vector< int > const *)arg1)->capacity();
resultobj = SWIG_From_size_t(static_cast< size_t >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete__intArray(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< int > *arg1 = (std::vector< int > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete__intArray",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__intArray" "', argument " "1"" of type '" "std::vector< int > *""'");
}
arg1 = reinterpret_cast< std::vector< int > * >(argp1);
delete arg1;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_intArray_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_new__Matx_int_2_1__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int *arg1 = (int *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
cv::Matx< int,2,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__Matx_int_2_1",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_int, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_int_2_1" "', argument " "1"" of type '" "int const *""'");
}
arg1 = reinterpret_cast< int * >(argp1);
result = (cv::Matx< int,2,1 > *)new cv::Matx< int,2,1 >((int const *)arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_int_2_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_int_2_1_all(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int val1 ;
int ecode1 = 0 ;
PyObject * obj0 = 0 ;
SwigValueWrapper< cv::Matx< int,2,1 > > result;
if (!PyArg_ParseTuple(args,(char *)"O:_Matx_int_2_1_all",&obj0)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_Matx_int_2_1_all" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
result = cv::Matx< int,2,1 >::SWIGTEMPLATEDISAMBIGUATOR all(arg1);
resultobj = SWIG_NewPointerObj((new cv::Matx< int,2,1 >(static_cast< const cv::Matx< int,2,1 >& >(result))), SWIGTYPE_p_cv__MatxT_int_2_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_int_2_1_zeros(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
SwigValueWrapper< cv::Matx< int,2,1 > > result;
if (!PyArg_ParseTuple(args,(char *)":_Matx_int_2_1_zeros")) SWIG_fail;
result = cv::Matx< int,2,1 >::SWIGTEMPLATEDISAMBIGUATOR zeros();
resultobj = SWIG_NewPointerObj((new cv::Matx< int,2,1 >(static_cast< const cv::Matx< int,2,1 >& >(result))), SWIGTYPE_p_cv__MatxT_int_2_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_int_2_1_ones(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
SwigValueWrapper< cv::Matx< int,2,1 > > result;
if (!PyArg_ParseTuple(args,(char *)":_Matx_int_2_1_ones")) SWIG_fail;
result = cv::Matx< int,2,1 >::SWIGTEMPLATEDISAMBIGUATOR ones();
resultobj = SWIG_NewPointerObj((new cv::Matx< int,2,1 >(static_cast< const cv::Matx< int,2,1 >& >(result))), SWIGTYPE_p_cv__MatxT_int_2_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_int_2_1_eye(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
SwigValueWrapper< cv::Matx< int,2,1 > > result;
if (!PyArg_ParseTuple(args,(char *)":_Matx_int_2_1_eye")) SWIG_fail;
result = cv::Matx< int,2,1 >::SWIGTEMPLATEDISAMBIGUATOR eye();
resultobj = SWIG_NewPointerObj((new cv::Matx< int,2,1 >(static_cast< const cv::Matx< int,2,1 >& >(result))), SWIGTYPE_p_cv__MatxT_int_2_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_int_2_1_randu(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 ;
SwigValueWrapper< cv::Matx< int,2,1 > > result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_int_2_1_randu",&obj0,&obj1)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_Matx_int_2_1_randu" "', 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 '" "_Matx_int_2_1_randu" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
result = cv::Matx< int,2,1 >::SWIGTEMPLATEDISAMBIGUATOR randu(arg1,arg2);
resultobj = SWIG_NewPointerObj((new cv::Matx< int,2,1 >(static_cast< const cv::Matx< int,2,1 >& >(result))), SWIGTYPE_p_cv__MatxT_int_2_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_int_2_1_randn(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 ;
SwigValueWrapper< cv::Matx< int,2,1 > > result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_int_2_1_randn",&obj0,&obj1)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_Matx_int_2_1_randn" "', 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 '" "_Matx_int_2_1_randn" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
result = cv::Matx< int,2,1 >::SWIGTEMPLATEDISAMBIGUATOR randn(arg1,arg2);
resultobj = SWIG_NewPointerObj((new cv::Matx< int,2,1 >(static_cast< const cv::Matx< int,2,1 >& >(result))), SWIGTYPE_p_cv__MatxT_int_2_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_int_2_1_dot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< int,2,1 > *arg1 = (cv::Matx< int,2,1 > *) 0 ;
cv::Matx< int,2,1 > *arg2 = 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:_Matx_int_2_1_dot",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_int_2_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_int_2_1_dot" "', argument " "1"" of type '" "cv::Matx< int,2,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< int,2,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_int_2_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_int_2_1_dot" "', argument " "2"" of type '" "cv::Matx< int,2,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Matx_int_2_1_dot" "', argument " "2"" of type '" "cv::Matx< int,2,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< int,2,1 > * >(argp2);
result = (int)((cv::Matx< int,2,1 > const *)arg1)->dot((cv::Matx< int,2,1 > const &)*arg2);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_int_2_1_ddot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< int,2,1 > *arg1 = (cv::Matx< int,2,1 > *) 0 ;
cv::Matx< int,2,1 > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
double result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_int_2_1_ddot",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_int_2_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_int_2_1_ddot" "', argument " "1"" of type '" "cv::Matx< int,2,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< int,2,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_int_2_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_int_2_1_ddot" "', argument " "2"" of type '" "cv::Matx< int,2,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Matx_int_2_1_ddot" "', argument " "2"" of type '" "cv::Matx< int,2,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< int,2,1 > * >(argp2);
result = (double)((cv::Matx< int,2,1 > const *)arg1)->ddot((cv::Matx< int,2,1 > const &)*arg2);
resultobj = SWIG_From_double(static_cast< double >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_int_2_1_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< int,2,1 > *arg1 = (cv::Matx< int,2,1 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
SwigValueWrapper< cv::Matx< int,1,2 > > result;
if (!PyArg_ParseTuple(args,(char *)"O:_Matx_int_2_1_t",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_int_2_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_int_2_1_t" "', argument " "1"" of type '" "cv::Matx< int,2,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< int,2,1 > * >(argp1);
result = ((cv::Matx< int,2,1 > const *)arg1)->t();
resultobj = SWIG_NewPointerObj((new cv::Matx< int,1,2 >(static_cast< const cv::Matx< int,1,2 >& >(result))), SWIGTYPE_p_cv__MatxT_int_1_2_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_int_2_1_mul(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< int,2,1 > *arg1 = (cv::Matx< int,2,1 > *) 0 ;
cv::Matx< int,2,1 > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
SwigValueWrapper< cv::Matx< int,2,1 > > result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_int_2_1_mul",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_int_2_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_int_2_1_mul" "', argument " "1"" of type '" "cv::Matx< int,2,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< int,2,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_int_2_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_int_2_1_mul" "', argument " "2"" of type '" "cv::Matx< int,2,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Matx_int_2_1_mul" "', argument " "2"" of type '" "cv::Matx< int,2,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< int,2,1 > * >(argp2);
result = ((cv::Matx< int,2,1 > const *)arg1)->mul((cv::Matx< int,2,1 > const &)*arg2);
resultobj = SWIG_NewPointerObj((new cv::Matx< int,2,1 >(static_cast< const cv::Matx< int,2,1 >& >(result))), SWIGTYPE_p_cv__MatxT_int_2_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_int_2_1_div(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< int,2,1 > *arg1 = (cv::Matx< int,2,1 > *) 0 ;
cv::Matx< int,2,1 > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
SwigValueWrapper< cv::Matx< int,2,1 > > result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_int_2_1_div",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_int_2_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_int_2_1_div" "', argument " "1"" of type '" "cv::Matx< int,2,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< int,2,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_int_2_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_int_2_1_div" "', argument " "2"" of type '" "cv::Matx< int,2,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Matx_int_2_1_div" "', argument " "2"" of type '" "cv::Matx< int,2,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< int,2,1 > * >(argp2);
result = ((cv::Matx< int,2,1 > const *)arg1)->div((cv::Matx< int,2,1 > const &)*arg2);
resultobj = SWIG_NewPointerObj((new cv::Matx< int,2,1 >(static_cast< const cv::Matx< int,2,1 >& >(result))), SWIGTYPE_p_cv__MatxT_int_2_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_int_2_1___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< int,2,1 > *arg1 = (cv::Matx< int,2,1 > *) 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 ;
int *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:_Matx_int_2_1___call__",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_int_2_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_int_2_1___call__" "', argument " "1"" of type '" "cv::Matx< int,2,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< int,2,1 > * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_Matx_int_2_1___call__" "', 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 '" "_Matx_int_2_1___call__" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
result = (int *) &((cv::Matx< int,2,1 > const *)arg1)->operator ()(arg2,arg3);
resultobj = SWIG_From_int(static_cast< int >(*result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_int_2_1__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< int,2,1 > *arg1 = 0 ;
cv::Matx< int,2,1 > *arg2 = 0 ;
cv::Matx_AddOp 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 ;
cv::Matx< int,2,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Matx_int_2_1",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_int_2_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_int_2_1" "', argument " "1"" of type '" "cv::Matx< int,2,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_int_2_1" "', argument " "1"" of type '" "cv::Matx< int,2,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< int,2,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_int_2_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Matx_int_2_1" "', argument " "2"" of type '" "cv::Matx< int,2,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_int_2_1" "', argument " "2"" of type '" "cv::Matx< int,2,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< int,2,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_AddOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Matx_int_2_1" "', argument " "3"" of type '" "cv::Matx_AddOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_int_2_1" "', argument " "3"" of type '" "cv::Matx_AddOp""'");
} else {
cv::Matx_AddOp * temp = reinterpret_cast< cv::Matx_AddOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Matx< int,2,1 > *)new cv::Matx< int,2,1 >((cv::Matx< int,2,1 > const &)*arg1,(cv::Matx< int,2,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_int_2_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_int_2_1__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< int,2,1 > *arg1 = 0 ;
cv::Matx< int,2,1 > *arg2 = 0 ;
cv::Matx_SubOp 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 ;
cv::Matx< int,2,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Matx_int_2_1",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_int_2_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_int_2_1" "', argument " "1"" of type '" "cv::Matx< int,2,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_int_2_1" "', argument " "1"" of type '" "cv::Matx< int,2,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< int,2,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_int_2_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Matx_int_2_1" "', argument " "2"" of type '" "cv::Matx< int,2,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_int_2_1" "', argument " "2"" of type '" "cv::Matx< int,2,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< int,2,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_SubOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Matx_int_2_1" "', argument " "3"" of type '" "cv::Matx_SubOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_int_2_1" "', argument " "3"" of type '" "cv::Matx_SubOp""'");
} else {
cv::Matx_SubOp * temp = reinterpret_cast< cv::Matx_SubOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Matx< int,2,1 > *)new cv::Matx< int,2,1 >((cv::Matx< int,2,1 > const &)*arg1,(cv::Matx< int,2,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_int_2_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_int_2_1__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< int,2,1 > *arg1 = 0 ;
cv::Matx< int,2,1 > *arg2 = 0 ;
cv::Matx_MulOp 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 ;
cv::Matx< int,2,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Matx_int_2_1",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_int_2_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_int_2_1" "', argument " "1"" of type '" "cv::Matx< int,2,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_int_2_1" "', argument " "1"" of type '" "cv::Matx< int,2,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< int,2,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_int_2_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Matx_int_2_1" "', argument " "2"" of type '" "cv::Matx< int,2,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_int_2_1" "', argument " "2"" of type '" "cv::Matx< int,2,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< int,2,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_MulOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Matx_int_2_1" "', argument " "3"" of type '" "cv::Matx_MulOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_int_2_1" "', argument " "3"" of type '" "cv::Matx_MulOp""'");
} else {
cv::Matx_MulOp * temp = reinterpret_cast< cv::Matx_MulOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Matx< int,2,1 > *)new cv::Matx< int,2,1 >((cv::Matx< int,2,1 > const &)*arg1,(cv::Matx< int,2,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_int_2_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_int_2_1__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< int,2,1 > *arg1 = 0 ;
cv::Matx< int,2,1 > *arg2 = 0 ;
cv::Matx_DivOp 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 ;
cv::Matx< int,2,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Matx_int_2_1",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_int_2_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_int_2_1" "', argument " "1"" of type '" "cv::Matx< int,2,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_int_2_1" "', argument " "1"" of type '" "cv::Matx< int,2,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< int,2,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_int_2_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Matx_int_2_1" "', argument " "2"" of type '" "cv::Matx< int,2,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_int_2_1" "', argument " "2"" of type '" "cv::Matx< int,2,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< int,2,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_DivOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Matx_int_2_1" "', argument " "3"" of type '" "cv::Matx_DivOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_int_2_1" "', argument " "3"" of type '" "cv::Matx_DivOp""'");
} else {
cv::Matx_DivOp * temp = reinterpret_cast< cv::Matx_DivOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Matx< int,2,1 > *)new cv::Matx< int,2,1 >((cv::Matx< int,2,1 > const &)*arg1,(cv::Matx< int,2,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_int_2_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_int_2_1__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< int,1,2 > *arg1 = 0 ;
cv::Matx_TOp arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
cv::Matx< int,2,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:new__Matx_int_2_1",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_int_1_2_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_int_2_1" "', argument " "1"" of type '" "cv::Matx< int,1,2 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_int_2_1" "', argument " "1"" of type '" "cv::Matx< int,1,2 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< int,1,2 > * >(argp1);
{
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__Matx_TOp, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Matx_int_2_1" "', argument " "2"" of type '" "cv::Matx_TOp""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_int_2_1" "', argument " "2"" of type '" "cv::Matx_TOp""'");
} else {
cv::Matx_TOp * temp = reinterpret_cast< cv::Matx_TOp * >(argp2);
arg2 = *temp;
if (SWIG_IsNewObj(res2)) delete temp;
}
}
result = (cv::Matx< int,2,1 > *)new cv::Matx< int,2,1 >((cv::Matx< int,1,2 > const &)*arg1,arg2);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_int_2_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_int_2_1_val_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< int,2,1 > *arg1 = (cv::Matx< int,2,1 > *) 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:_Matx_int_2_1_val_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_int_2_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_int_2_1_val_set" "', argument " "1"" of type '" "cv::Matx< int,2,1 > *""'");
}
arg1 = reinterpret_cast< cv::Matx< int,2,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_int, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_int_2_1_val_set" "', argument " "2"" of type '" "int [2*1]""'");
}
arg2 = reinterpret_cast< int * >(argp2);
{
if (arg2) {
size_t ii = 0;
for (; ii < (size_t)2*1; ++ii) *(int *)&arg1->val[ii] = *((int *)arg2 + ii);
} else {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""val""' of type '""int [2*1]""'");
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_int_2_1_val_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< int,2,1 > *arg1 = (cv::Matx< int,2,1 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:_Matx_int_2_1_val_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_int_2_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_int_2_1_val_get" "', argument " "1"" of type '" "cv::Matx< int,2,1 > *""'");
}
arg1 = reinterpret_cast< cv::Matx< int,2,1 > * >(argp1);
result = (int *)(int *) ((arg1)->val);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_int_2_1__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< cv::Matx< int,2,1 >::value_type,std::allocator< cv::Matx< int,2,1 >::value_type > > arg1 ;
PyObject * obj0 = 0 ;
cv::Matx< int,2,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__Matx_int_2_1",&obj0)) SWIG_fail;
{
std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
int res = swig::asptr(obj0, &ptr);
if (!SWIG_IsOK(res) || !ptr) {
SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new__Matx_int_2_1" "', argument " "1"" of type '" "std::vector< cv::Matx< int,2,1 >::value_type,std::allocator< cv::Matx< int,2,1 >::value_type > >""'");
}
arg1 = *ptr;
if (SWIG_IsNewObj(res)) delete ptr;
}
result = (cv::Matx< int,2,1 > *)new_cv_Matx_Sl_int_Sc_2_Sc_1_Sg___SWIG_6(arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_int_2_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_int_2_1(PyObject *self, PyObject *args) {
Py_ssize_t argc;
PyObject *argv[4] = {
0
};
Py_ssize_t ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = args ? PyObject_Length(args) : 0;
for (ii = 0; (ii < 3) && (ii < argc); 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_int, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_int_2_1__SWIG_0(self, args);
}
}
if (argc == 1) {
int _v;
int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_int_2_1__SWIG_6(self, args);
}
}
if (argc == 2) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_int_1_2_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__Matx_TOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_int_2_1__SWIG_5(self, args);
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_int_2_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_int_2_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_MulOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_int_2_1__SWIG_3(self, args);
}
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_int_2_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_int_2_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_DivOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_int_2_1__SWIG_4(self, args);
}
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_int_2_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_int_2_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_AddOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_int_2_1__SWIG_1(self, args);
}
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_int_2_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_int_2_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_SubOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_int_2_1__SWIG_2(self, args);
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new__Matx_int_2_1'.\n"
" Possible C/C++ prototypes are:\n"
" cv::Matx< int,2,1 >::Matx(int const *)\n"
" cv::Matx< int,2,1 >::Matx(cv::Matx< int,2,1 > const &,cv::Matx< int,2,1 > const &,cv::Matx_AddOp)\n"
" cv::Matx< int,2,1 >::Matx(cv::Matx< int,2,1 > const &,cv::Matx< int,2,1 > const &,cv::Matx_SubOp)\n"
" cv::Matx< int,2,1 >::Matx(cv::Matx< int,2,1 > const &,cv::Matx< int,2,1 > const &,cv::Matx_MulOp)\n"
" cv::Matx< int,2,1 >::Matx(cv::Matx< int,2,1 > const &,cv::Matx< int,2,1 > const &,cv::Matx_DivOp)\n"
" cv::Matx< int,2,1 >::Matx(cv::Matx< int,1,2 > const &,cv::Matx_TOp)\n"
" cv::Matx< int,2,1 >::Matx(std::vector< cv::Matx< int,2,1 >::value_type,std::allocator< cv::Matx< int,2,1 >::value_type > >)\n");
return 0;
}
SWIGINTERN PyObject *_wrap__Matx_int_2_1___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< int,2,1 > *arg1 = (cv::Matx< int,2,1 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
std::string result;
if (!PyArg_ParseTuple(args,(char *)"O:_Matx_int_2_1___str__",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_int_2_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_int_2_1___str__" "', argument " "1"" of type '" "cv::Matx< int,2,1 > *""'");
}
arg1 = reinterpret_cast< cv::Matx< int,2,1 > * >(argp1);
result = cv_Matx_Sl_int_Sc_2_Sc_1_Sg____str__(arg1);
resultobj = SWIG_From_std_string(static_cast< std::string >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete__Matx_int_2_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< int,2,1 > *arg1 = (cv::Matx< int,2,1 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete__Matx_int_2_1",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_int_2_1_t, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__Matx_int_2_1" "', argument " "1"" of type '" "cv::Matx< int,2,1 > *""'");
}
arg1 = reinterpret_cast< cv::Matx< int,2,1 > * >(argp1);
delete arg1;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_Matx_int_2_1_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_cv__MatxT_int_2_1_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_new__Vec_int_2__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int *arg1 = (int *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
cv::Vec< int,2 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__Vec_int_2",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_int, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Vec_int_2" "', argument " "1"" of type '" "int const *""'");
}
arg1 = reinterpret_cast< int * >(argp1);
result = (cv::Vec< int,2 > *)new cv::Vec< int,2 >((int const *)arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__VecT_int_2_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Vec_int_2__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Vec< int,2 > *arg1 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
cv::Vec< int,2 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__Vec_int_2",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__VecT_int_2_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Vec_int_2" "', argument " "1"" of type '" "cv::Vec< int,2 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_int_2" "', argument " "1"" of type '" "cv::Vec< int,2 > const &""'");
}
arg1 = reinterpret_cast< cv::Vec< int,2 > * >(argp1);
result = (cv::Vec< int,2 > *)new cv::Vec< int,2 >((cv::Vec< int,2 > const &)*arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__VecT_int_2_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Vec_int_2_all(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int val1 ;
int ecode1 = 0 ;
PyObject * obj0 = 0 ;
SwigValueWrapper< cv::Vec< int,2 > > result;
if (!PyArg_ParseTuple(args,(char *)"O:_Vec_int_2_all",&obj0)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_Vec_int_2_all" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
result = cv::Vec< int,2 >::SWIGTEMPLATEDISAMBIGUATOR all(arg1);
resultobj = SWIG_NewPointerObj((new cv::Vec< int,2 >(static_cast< const cv::Vec< int,2 >& >(result))), SWIGTYPE_p_cv__VecT_int_2_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Vec_int_2_mul(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Vec< int,2 > *arg1 = (cv::Vec< int,2 > *) 0 ;
cv::Vec< int,2 > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
SwigValueWrapper< cv::Vec< int,2 > > result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Vec_int_2_mul",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__VecT_int_2_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Vec_int_2_mul" "', argument " "1"" of type '" "cv::Vec< int,2 > const *""'");
}
arg1 = reinterpret_cast< cv::Vec< int,2 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__VecT_int_2_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Vec_int_2_mul" "', argument " "2"" of type '" "cv::Vec< int,2 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Vec_int_2_mul" "', argument " "2"" of type '" "cv::Vec< int,2 > const &""'");
}
arg2 = reinterpret_cast< cv::Vec< int,2 > * >(argp2);
result = ((cv::Vec< int,2 > const *)arg1)->mul((cv::Vec< int,2 > const &)*arg2);
resultobj = SWIG_NewPointerObj((new cv::Vec< int,2 >(static_cast< const cv::Vec< int,2 >& >(result))), SWIGTYPE_p_cv__VecT_int_2_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Vec_int_2___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Vec< int,2 > *arg1 = (cv::Vec< int,2 > *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
int *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:_Vec_int_2___call__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__VecT_int_2_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Vec_int_2___call__" "', argument " "1"" of type '" "cv::Vec< int,2 > const *""'");
}
arg1 = reinterpret_cast< cv::Vec< int,2 > * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_Vec_int_2___call__" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
result = (int *) &((cv::Vec< int,2 > const *)arg1)->operator ()(arg2);
resultobj = SWIG_From_int(static_cast< int >(*result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Vec_int_2__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< int,2,1 > *arg1 = 0 ;
cv::Matx< int,2,1 > *arg2 = 0 ;
cv::Matx_AddOp 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 ;
cv::Vec< int,2 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Vec_int_2",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_int_2_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Vec_int_2" "', argument " "1"" of type '" "cv::Matx< int,2,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_int_2" "', argument " "1"" of type '" "cv::Matx< int,2,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< int,2,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_int_2_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Vec_int_2" "', argument " "2"" of type '" "cv::Matx< int,2,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_int_2" "', argument " "2"" of type '" "cv::Matx< int,2,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< int,2,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_AddOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Vec_int_2" "', argument " "3"" of type '" "cv::Matx_AddOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_int_2" "', argument " "3"" of type '" "cv::Matx_AddOp""'");
} else {
cv::Matx_AddOp * temp = reinterpret_cast< cv::Matx_AddOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Vec< int,2 > *)new cv::Vec< int,2 >((cv::Matx< int,2,1 > const &)*arg1,(cv::Matx< int,2,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__VecT_int_2_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Vec_int_2__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< int,2,1 > *arg1 = 0 ;
cv::Matx< int,2,1 > *arg2 = 0 ;
cv::Matx_SubOp 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 ;
cv::Vec< int,2 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Vec_int_2",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_int_2_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Vec_int_2" "', argument " "1"" of type '" "cv::Matx< int,2,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_int_2" "', argument " "1"" of type '" "cv::Matx< int,2,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< int,2,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_int_2_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Vec_int_2" "', argument " "2"" of type '" "cv::Matx< int,2,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_int_2" "', argument " "2"" of type '" "cv::Matx< int,2,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< int,2,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_SubOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Vec_int_2" "', argument " "3"" of type '" "cv::Matx_SubOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_int_2" "', argument " "3"" of type '" "cv::Matx_SubOp""'");
} else {
cv::Matx_SubOp * temp = reinterpret_cast< cv::Matx_SubOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Vec< int,2 > *)new cv::Vec< int,2 >((cv::Matx< int,2,1 > const &)*arg1,(cv::Matx< int,2,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__VecT_int_2_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Vec_int_2__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< cv::Vec< int,2 >::value_type,std::allocator< cv::Vec< int,2 >::value_type > > arg1 ;
PyObject * obj0 = 0 ;
cv::Vec< int,2 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__Vec_int_2",&obj0)) SWIG_fail;
{
std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
int res = swig::asptr(obj0, &ptr);
if (!SWIG_IsOK(res) || !ptr) {
SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new__Vec_int_2" "', argument " "1"" of type '" "std::vector< cv::Vec< int,2 >::value_type,std::allocator< cv::Vec< int,2 >::value_type > >""'");
}
arg1 = *ptr;
if (SWIG_IsNewObj(res)) delete ptr;
}
result = (cv::Vec< int,2 > *)new_cv_Vec_Sl_int_Sc_2_Sg___SWIG_4(arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__VecT_int_2_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Vec_int_2(PyObject *self, PyObject *args) {
Py_ssize_t argc;
PyObject *argv[4] = {
0
};
Py_ssize_t ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = args ? PyObject_Length(args) : 0;
for (ii = 0; (ii < 3) && (ii < argc); 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_int, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Vec_int_2__SWIG_0(self, args);
}
}
if (argc == 1) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__VecT_int_2_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Vec_int_2__SWIG_1(self, args);
}
}
if (argc == 1) {
int _v;
int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Vec_int_2__SWIG_4(self, args);
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_int_2_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_int_2_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_SubOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Vec_int_2__SWIG_3(self, args);
}
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_int_2_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_int_2_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_AddOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Vec_int_2__SWIG_2(self, args);
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new__Vec_int_2'.\n"
" Possible C/C++ prototypes are:\n"
" cv::Vec< int,2 >::Vec(int const *)\n"
" cv::Vec< int,2 >::Vec(cv::Vec< int,2 > const &)\n"
" cv::Vec< int,2 >::Vec(cv::Matx< int,2,1 > const &,cv::Matx< int,2,1 > const &,cv::Matx_AddOp)\n"
" cv::Vec< int,2 >::Vec(cv::Matx< int,2,1 > const &,cv::Matx< int,2,1 > const &,cv::Matx_SubOp)\n"
" cv::Vec< int,2 >::Vec(std::vector< cv::Vec< int,2 >::value_type,std::allocator< cv::Vec< int,2 >::value_type > >)\n");
return 0;
}
SWIGINTERN PyObject *_wrap__Vec_int_2___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Vec< int,2 > *arg1 = (cv::Vec< int,2 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
std::string result;
if (!PyArg_ParseTuple(args,(char *)"O:_Vec_int_2___str__",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__VecT_int_2_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Vec_int_2___str__" "', argument " "1"" of type '" "cv::Vec< int,2 > *""'");
}
arg1 = reinterpret_cast< cv::Vec< int,2 > * >(argp1);
result = cv_Vec_Sl_int_Sc_2_Sg____str__(arg1);
resultobj = SWIG_From_std_string(static_cast< std::string >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete__Vec_int_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Vec< int,2 > *arg1 = (cv::Vec< int,2 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete__Vec_int_2",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__VecT_int_2_t, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__Vec_int_2" "', argument " "1"" of type '" "cv::Vec< int,2 > *""'");
}
arg1 = reinterpret_cast< cv::Vec< int,2 > * >(argp1);
delete arg1;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_Vec_int_2_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_cv__VecT_int_2_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_new__DataType_Vec_int_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::DataType< cv::Vec< int,2 > > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new__DataType_Vec_int_2")) SWIG_fail;
result = (cv::DataType< cv::Vec< int,2 > > *)new cv::DataType< cv::Vec< int,2 > >();
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__DataTypeT_cv__VecT_int_2_t_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete__DataType_Vec_int_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::DataType< cv::Vec< int,2 > > *arg1 = (cv::DataType< cv::Vec< int,2 > > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete__DataType_Vec_int_2",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__DataTypeT_cv__VecT_int_2_t_t, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__DataType_Vec_int_2" "', argument " "1"" of type '" "cv::DataType< cv::Vec< int,2 > > *""'");
}
arg1 = reinterpret_cast< cv::DataType< cv::Vec< int,2 > > * >(argp1);
delete arg1;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_DataType_Vec_int_2_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_cv__DataTypeT_cv__VecT_int_2_t_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_new__Matx_int_3_1__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int *arg1 = (int *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
cv::Matx< int,3,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__Matx_int_3_1",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_int, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_int_3_1" "', argument " "1"" of type '" "int const *""'");
}
arg1 = reinterpret_cast< int * >(argp1);
result = (cv::Matx< int,3,1 > *)new cv::Matx< int,3,1 >((int const *)arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_int_3_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_int_3_1_all(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int val1 ;
int ecode1 = 0 ;
PyObject * obj0 = 0 ;
SwigValueWrapper< cv::Matx< int,3,1 > > result;
if (!PyArg_ParseTuple(args,(char *)"O:_Matx_int_3_1_all",&obj0)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_Matx_int_3_1_all" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
result = cv::Matx< int,3,1 >::SWIGTEMPLATEDISAMBIGUATOR all(arg1);
resultobj = SWIG_NewPointerObj((new cv::Matx< int,3,1 >(static_cast< const cv::Matx< int,3,1 >& >(result))), SWIGTYPE_p_cv__MatxT_int_3_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_int_3_1_zeros(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
SwigValueWrapper< cv::Matx< int,3,1 > > result;
if (!PyArg_ParseTuple(args,(char *)":_Matx_int_3_1_zeros")) SWIG_fail;
result = cv::Matx< int,3,1 >::SWIGTEMPLATEDISAMBIGUATOR zeros();
resultobj = SWIG_NewPointerObj((new cv::Matx< int,3,1 >(static_cast< const cv::Matx< int,3,1 >& >(result))), SWIGTYPE_p_cv__MatxT_int_3_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_int_3_1_ones(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
SwigValueWrapper< cv::Matx< int,3,1 > > result;
if (!PyArg_ParseTuple(args,(char *)":_Matx_int_3_1_ones")) SWIG_fail;
result = cv::Matx< int,3,1 >::SWIGTEMPLATEDISAMBIGUATOR ones();
resultobj = SWIG_NewPointerObj((new cv::Matx< int,3,1 >(static_cast< const cv::Matx< int,3,1 >& >(result))), SWIGTYPE_p_cv__MatxT_int_3_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_int_3_1_eye(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
SwigValueWrapper< cv::Matx< int,3,1 > > result;
if (!PyArg_ParseTuple(args,(char *)":_Matx_int_3_1_eye")) SWIG_fail;
result = cv::Matx< int,3,1 >::SWIGTEMPLATEDISAMBIGUATOR eye();
resultobj = SWIG_NewPointerObj((new cv::Matx< int,3,1 >(static_cast< const cv::Matx< int,3,1 >& >(result))), SWIGTYPE_p_cv__MatxT_int_3_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_int_3_1_randu(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 ;
SwigValueWrapper< cv::Matx< int,3,1 > > result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_int_3_1_randu",&obj0,&obj1)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_Matx_int_3_1_randu" "', 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 '" "_Matx_int_3_1_randu" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
result = cv::Matx< int,3,1 >::SWIGTEMPLATEDISAMBIGUATOR randu(arg1,arg2);
resultobj = SWIG_NewPointerObj((new cv::Matx< int,3,1 >(static_cast< const cv::Matx< int,3,1 >& >(result))), SWIGTYPE_p_cv__MatxT_int_3_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_int_3_1_randn(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 ;
SwigValueWrapper< cv::Matx< int,3,1 > > result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_int_3_1_randn",&obj0,&obj1)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_Matx_int_3_1_randn" "', 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 '" "_Matx_int_3_1_randn" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
result = cv::Matx< int,3,1 >::SWIGTEMPLATEDISAMBIGUATOR randn(arg1,arg2);
resultobj = SWIG_NewPointerObj((new cv::Matx< int,3,1 >(static_cast< const cv::Matx< int,3,1 >& >(result))), SWIGTYPE_p_cv__MatxT_int_3_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_int_3_1_dot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< int,3,1 > *arg1 = (cv::Matx< int,3,1 > *) 0 ;
cv::Matx< int,3,1 > *arg2 = 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:_Matx_int_3_1_dot",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_int_3_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_int_3_1_dot" "', argument " "1"" of type '" "cv::Matx< int,3,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< int,3,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_int_3_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_int_3_1_dot" "', argument " "2"" of type '" "cv::Matx< int,3,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Matx_int_3_1_dot" "', argument " "2"" of type '" "cv::Matx< int,3,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< int,3,1 > * >(argp2);
result = (int)((cv::Matx< int,3,1 > const *)arg1)->dot((cv::Matx< int,3,1 > const &)*arg2);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_int_3_1_ddot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< int,3,1 > *arg1 = (cv::Matx< int,3,1 > *) 0 ;
cv::Matx< int,3,1 > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
double result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_int_3_1_ddot",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_int_3_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_int_3_1_ddot" "', argument " "1"" of type '" "cv::Matx< int,3,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< int,3,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_int_3_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_int_3_1_ddot" "', argument " "2"" of type '" "cv::Matx< int,3,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Matx_int_3_1_ddot" "', argument " "2"" of type '" "cv::Matx< int,3,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< int,3,1 > * >(argp2);
result = (double)((cv::Matx< int,3,1 > const *)arg1)->ddot((cv::Matx< int,3,1 > const &)*arg2);
resultobj = SWIG_From_double(static_cast< double >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_int_3_1_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< int,3,1 > *arg1 = (cv::Matx< int,3,1 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
SwigValueWrapper< cv::Matx< int,1,3 > > result;
if (!PyArg_ParseTuple(args,(char *)"O:_Matx_int_3_1_t",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_int_3_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_int_3_1_t" "', argument " "1"" of type '" "cv::Matx< int,3,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< int,3,1 > * >(argp1);
result = ((cv::Matx< int,3,1 > const *)arg1)->t();
resultobj = SWIG_NewPointerObj((new cv::Matx< int,1,3 >(static_cast< const cv::Matx< int,1,3 >& >(result))), SWIGTYPE_p_cv__MatxT_int_1_3_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_int_3_1_mul(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< int,3,1 > *arg1 = (cv::Matx< int,3,1 > *) 0 ;
cv::Matx< int,3,1 > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
SwigValueWrapper< cv::Matx< int,3,1 > > result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_int_3_1_mul",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_int_3_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_int_3_1_mul" "', argument " "1"" of type '" "cv::Matx< int,3,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< int,3,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_int_3_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_int_3_1_mul" "', argument " "2"" of type '" "cv::Matx< int,3,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Matx_int_3_1_mul" "', argument " "2"" of type '" "cv::Matx< int,3,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< int,3,1 > * >(argp2);
result = ((cv::Matx< int,3,1 > const *)arg1)->mul((cv::Matx< int,3,1 > const &)*arg2);
resultobj = SWIG_NewPointerObj((new cv::Matx< int,3,1 >(static_cast< const cv::Matx< int,3,1 >& >(result))), SWIGTYPE_p_cv__MatxT_int_3_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_int_3_1_div(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< int,3,1 > *arg1 = (cv::Matx< int,3,1 > *) 0 ;
cv::Matx< int,3,1 > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
SwigValueWrapper< cv::Matx< int,3,1 > > result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_int_3_1_div",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_int_3_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_int_3_1_div" "', argument " "1"" of type '" "cv::Matx< int,3,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< int,3,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_int_3_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_int_3_1_div" "', argument " "2"" of type '" "cv::Matx< int,3,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Matx_int_3_1_div" "', argument " "2"" of type '" "cv::Matx< int,3,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< int,3,1 > * >(argp2);
result = ((cv::Matx< int,3,1 > const *)arg1)->div((cv::Matx< int,3,1 > const &)*arg2);
resultobj = SWIG_NewPointerObj((new cv::Matx< int,3,1 >(static_cast< const cv::Matx< int,3,1 >& >(result))), SWIGTYPE_p_cv__MatxT_int_3_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_int_3_1___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< int,3,1 > *arg1 = (cv::Matx< int,3,1 > *) 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 ;
int *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:_Matx_int_3_1___call__",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_int_3_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_int_3_1___call__" "', argument " "1"" of type '" "cv::Matx< int,3,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< int,3,1 > * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_Matx_int_3_1___call__" "', 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 '" "_Matx_int_3_1___call__" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
result = (int *) &((cv::Matx< int,3,1 > const *)arg1)->operator ()(arg2,arg3);
resultobj = SWIG_From_int(static_cast< int >(*result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_int_3_1__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< int,3,1 > *arg1 = 0 ;
cv::Matx< int,3,1 > *arg2 = 0 ;
cv::Matx_AddOp 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 ;
cv::Matx< int,3,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Matx_int_3_1",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_int_3_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_int_3_1" "', argument " "1"" of type '" "cv::Matx< int,3,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_int_3_1" "', argument " "1"" of type '" "cv::Matx< int,3,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< int,3,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_int_3_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Matx_int_3_1" "', argument " "2"" of type '" "cv::Matx< int,3,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_int_3_1" "', argument " "2"" of type '" "cv::Matx< int,3,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< int,3,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_AddOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Matx_int_3_1" "', argument " "3"" of type '" "cv::Matx_AddOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_int_3_1" "', argument " "3"" of type '" "cv::Matx_AddOp""'");
} else {
cv::Matx_AddOp * temp = reinterpret_cast< cv::Matx_AddOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Matx< int,3,1 > *)new cv::Matx< int,3,1 >((cv::Matx< int,3,1 > const &)*arg1,(cv::Matx< int,3,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_int_3_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_int_3_1__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< int,3,1 > *arg1 = 0 ;
cv::Matx< int,3,1 > *arg2 = 0 ;
cv::Matx_SubOp 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 ;
cv::Matx< int,3,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Matx_int_3_1",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_int_3_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_int_3_1" "', argument " "1"" of type '" "cv::Matx< int,3,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_int_3_1" "', argument " "1"" of type '" "cv::Matx< int,3,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< int,3,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_int_3_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Matx_int_3_1" "', argument " "2"" of type '" "cv::Matx< int,3,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_int_3_1" "', argument " "2"" of type '" "cv::Matx< int,3,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< int,3,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_SubOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Matx_int_3_1" "', argument " "3"" of type '" "cv::Matx_SubOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_int_3_1" "', argument " "3"" of type '" "cv::Matx_SubOp""'");
} else {
cv::Matx_SubOp * temp = reinterpret_cast< cv::Matx_SubOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Matx< int,3,1 > *)new cv::Matx< int,3,1 >((cv::Matx< int,3,1 > const &)*arg1,(cv::Matx< int,3,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_int_3_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_int_3_1__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< int,3,1 > *arg1 = 0 ;
cv::Matx< int,3,1 > *arg2 = 0 ;
cv::Matx_MulOp 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 ;
cv::Matx< int,3,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Matx_int_3_1",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_int_3_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_int_3_1" "', argument " "1"" of type '" "cv::Matx< int,3,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_int_3_1" "', argument " "1"" of type '" "cv::Matx< int,3,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< int,3,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_int_3_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Matx_int_3_1" "', argument " "2"" of type '" "cv::Matx< int,3,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_int_3_1" "', argument " "2"" of type '" "cv::Matx< int,3,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< int,3,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_MulOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Matx_int_3_1" "', argument " "3"" of type '" "cv::Matx_MulOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_int_3_1" "', argument " "3"" of type '" "cv::Matx_MulOp""'");
} else {
cv::Matx_MulOp * temp = reinterpret_cast< cv::Matx_MulOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Matx< int,3,1 > *)new cv::Matx< int,3,1 >((cv::Matx< int,3,1 > const &)*arg1,(cv::Matx< int,3,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_int_3_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_int_3_1__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< int,3,1 > *arg1 = 0 ;
cv::Matx< int,3,1 > *arg2 = 0 ;
cv::Matx_DivOp 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 ;
cv::Matx< int,3,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Matx_int_3_1",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_int_3_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_int_3_1" "', argument " "1"" of type '" "cv::Matx< int,3,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_int_3_1" "', argument " "1"" of type '" "cv::Matx< int,3,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< int,3,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_int_3_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Matx_int_3_1" "', argument " "2"" of type '" "cv::Matx< int,3,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_int_3_1" "', argument " "2"" of type '" "cv::Matx< int,3,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< int,3,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_DivOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Matx_int_3_1" "', argument " "3"" of type '" "cv::Matx_DivOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_int_3_1" "', argument " "3"" of type '" "cv::Matx_DivOp""'");
} else {
cv::Matx_DivOp * temp = reinterpret_cast< cv::Matx_DivOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Matx< int,3,1 > *)new cv::Matx< int,3,1 >((cv::Matx< int,3,1 > const &)*arg1,(cv::Matx< int,3,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_int_3_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_int_3_1__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< int,1,3 > *arg1 = 0 ;
cv::Matx_TOp arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
cv::Matx< int,3,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:new__Matx_int_3_1",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_int_1_3_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_int_3_1" "', argument " "1"" of type '" "cv::Matx< int,1,3 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_int_3_1" "', argument " "1"" of type '" "cv::Matx< int,1,3 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< int,1,3 > * >(argp1);
{
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__Matx_TOp, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Matx_int_3_1" "', argument " "2"" of type '" "cv::Matx_TOp""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_int_3_1" "', argument " "2"" of type '" "cv::Matx_TOp""'");
} else {
cv::Matx_TOp * temp = reinterpret_cast< cv::Matx_TOp * >(argp2);
arg2 = *temp;
if (SWIG_IsNewObj(res2)) delete temp;
}
}
result = (cv::Matx< int,3,1 > *)new cv::Matx< int,3,1 >((cv::Matx< int,1,3 > const &)*arg1,arg2);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_int_3_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_int_3_1_val_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< int,3,1 > *arg1 = (cv::Matx< int,3,1 > *) 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:_Matx_int_3_1_val_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_int_3_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_int_3_1_val_set" "', argument " "1"" of type '" "cv::Matx< int,3,1 > *""'");
}
arg1 = reinterpret_cast< cv::Matx< int,3,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_int, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_int_3_1_val_set" "', argument " "2"" of type '" "int [3*1]""'");
}
arg2 = reinterpret_cast< int * >(argp2);
{
if (arg2) {
size_t ii = 0;
for (; ii < (size_t)3*1; ++ii) *(int *)&arg1->val[ii] = *((int *)arg2 + ii);
} else {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""val""' of type '""int [3*1]""'");
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_int_3_1_val_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< int,3,1 > *arg1 = (cv::Matx< int,3,1 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:_Matx_int_3_1_val_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_int_3_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_int_3_1_val_get" "', argument " "1"" of type '" "cv::Matx< int,3,1 > *""'");
}
arg1 = reinterpret_cast< cv::Matx< int,3,1 > * >(argp1);
result = (int *)(int *) ((arg1)->val);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_int_3_1__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< cv::Matx< int,3,1 >::value_type,std::allocator< cv::Matx< int,3,1 >::value_type > > arg1 ;
PyObject * obj0 = 0 ;
cv::Matx< int,3,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__Matx_int_3_1",&obj0)) SWIG_fail;
{
std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
int res = swig::asptr(obj0, &ptr);
if (!SWIG_IsOK(res) || !ptr) {
SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new__Matx_int_3_1" "', argument " "1"" of type '" "std::vector< cv::Matx< int,3,1 >::value_type,std::allocator< cv::Matx< int,3,1 >::value_type > >""'");
}
arg1 = *ptr;
if (SWIG_IsNewObj(res)) delete ptr;
}
result = (cv::Matx< int,3,1 > *)new_cv_Matx_Sl_int_Sc_3_Sc_1_Sg___SWIG_6(arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_int_3_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_int_3_1(PyObject *self, PyObject *args) {
Py_ssize_t argc;
PyObject *argv[4] = {
0
};
Py_ssize_t ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = args ? PyObject_Length(args) : 0;
for (ii = 0; (ii < 3) && (ii < argc); 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_int, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_int_3_1__SWIG_0(self, args);
}
}
if (argc == 1) {
int _v;
int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_int_3_1__SWIG_6(self, args);
}
}
if (argc == 2) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_int_1_3_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__Matx_TOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_int_3_1__SWIG_5(self, args);
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_int_3_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_int_3_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_MulOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_int_3_1__SWIG_3(self, args);
}
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_int_3_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_int_3_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_DivOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_int_3_1__SWIG_4(self, args);
}
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_int_3_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_int_3_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_AddOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_int_3_1__SWIG_1(self, args);
}
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_int_3_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_int_3_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_SubOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_int_3_1__SWIG_2(self, args);
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new__Matx_int_3_1'.\n"
" Possible C/C++ prototypes are:\n"
" cv::Matx< int,3,1 >::Matx(int const *)\n"
" cv::Matx< int,3,1 >::Matx(cv::Matx< int,3,1 > const &,cv::Matx< int,3,1 > const &,cv::Matx_AddOp)\n"
" cv::Matx< int,3,1 >::Matx(cv::Matx< int,3,1 > const &,cv::Matx< int,3,1 > const &,cv::Matx_SubOp)\n"
" cv::Matx< int,3,1 >::Matx(cv::Matx< int,3,1 > const &,cv::Matx< int,3,1 > const &,cv::Matx_MulOp)\n"
" cv::Matx< int,3,1 >::Matx(cv::Matx< int,3,1 > const &,cv::Matx< int,3,1 > const &,cv::Matx_DivOp)\n"
" cv::Matx< int,3,1 >::Matx(cv::Matx< int,1,3 > const &,cv::Matx_TOp)\n"
" cv::Matx< int,3,1 >::Matx(std::vector< cv::Matx< int,3,1 >::value_type,std::allocator< cv::Matx< int,3,1 >::value_type > >)\n");
return 0;
}
SWIGINTERN PyObject *_wrap__Matx_int_3_1___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< int,3,1 > *arg1 = (cv::Matx< int,3,1 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
std::string result;
if (!PyArg_ParseTuple(args,(char *)"O:_Matx_int_3_1___str__",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_int_3_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_int_3_1___str__" "', argument " "1"" of type '" "cv::Matx< int,3,1 > *""'");
}
arg1 = reinterpret_cast< cv::Matx< int,3,1 > * >(argp1);
result = cv_Matx_Sl_int_Sc_3_Sc_1_Sg____str__(arg1);
resultobj = SWIG_From_std_string(static_cast< std::string >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete__Matx_int_3_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< int,3,1 > *arg1 = (cv::Matx< int,3,1 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete__Matx_int_3_1",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_int_3_1_t, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__Matx_int_3_1" "', argument " "1"" of type '" "cv::Matx< int,3,1 > *""'");
}
arg1 = reinterpret_cast< cv::Matx< int,3,1 > * >(argp1);
delete arg1;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_Matx_int_3_1_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_cv__MatxT_int_3_1_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_new__Vec_int_3__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int *arg1 = (int *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
cv::Vec< int,3 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__Vec_int_3",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_int, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Vec_int_3" "', argument " "1"" of type '" "int const *""'");
}
arg1 = reinterpret_cast< int * >(argp1);
result = (cv::Vec< int,3 > *)new cv::Vec< int,3 >((int const *)arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__VecT_int_3_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Vec_int_3__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Vec< int,3 > *arg1 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
cv::Vec< int,3 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__Vec_int_3",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__VecT_int_3_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Vec_int_3" "', argument " "1"" of type '" "cv::Vec< int,3 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_int_3" "', argument " "1"" of type '" "cv::Vec< int,3 > const &""'");
}
arg1 = reinterpret_cast< cv::Vec< int,3 > * >(argp1);
result = (cv::Vec< int,3 > *)new cv::Vec< int,3 >((cv::Vec< int,3 > const &)*arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__VecT_int_3_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Vec_int_3_all(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int val1 ;
int ecode1 = 0 ;
PyObject * obj0 = 0 ;
SwigValueWrapper< cv::Vec< int,3 > > result;
if (!PyArg_ParseTuple(args,(char *)"O:_Vec_int_3_all",&obj0)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_Vec_int_3_all" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
result = cv::Vec< int,3 >::SWIGTEMPLATEDISAMBIGUATOR all(arg1);
resultobj = SWIG_NewPointerObj((new cv::Vec< int,3 >(static_cast< const cv::Vec< int,3 >& >(result))), SWIGTYPE_p_cv__VecT_int_3_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Vec_int_3_mul(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Vec< int,3 > *arg1 = (cv::Vec< int,3 > *) 0 ;
cv::Vec< int,3 > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
SwigValueWrapper< cv::Vec< int,3 > > result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Vec_int_3_mul",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__VecT_int_3_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Vec_int_3_mul" "', argument " "1"" of type '" "cv::Vec< int,3 > const *""'");
}
arg1 = reinterpret_cast< cv::Vec< int,3 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__VecT_int_3_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Vec_int_3_mul" "', argument " "2"" of type '" "cv::Vec< int,3 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Vec_int_3_mul" "', argument " "2"" of type '" "cv::Vec< int,3 > const &""'");
}
arg2 = reinterpret_cast< cv::Vec< int,3 > * >(argp2);
result = ((cv::Vec< int,3 > const *)arg1)->mul((cv::Vec< int,3 > const &)*arg2);
resultobj = SWIG_NewPointerObj((new cv::Vec< int,3 >(static_cast< const cv::Vec< int,3 >& >(result))), SWIGTYPE_p_cv__VecT_int_3_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Vec_int_3___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Vec< int,3 > *arg1 = (cv::Vec< int,3 > *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
int *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:_Vec_int_3___call__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__VecT_int_3_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Vec_int_3___call__" "', argument " "1"" of type '" "cv::Vec< int,3 > const *""'");
}
arg1 = reinterpret_cast< cv::Vec< int,3 > * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_Vec_int_3___call__" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
result = (int *) &((cv::Vec< int,3 > const *)arg1)->operator ()(arg2);
resultobj = SWIG_From_int(static_cast< int >(*result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Vec_int_3__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< int,3,1 > *arg1 = 0 ;
cv::Matx< int,3,1 > *arg2 = 0 ;
cv::Matx_AddOp 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 ;
cv::Vec< int,3 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Vec_int_3",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_int_3_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Vec_int_3" "', argument " "1"" of type '" "cv::Matx< int,3,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_int_3" "', argument " "1"" of type '" "cv::Matx< int,3,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< int,3,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_int_3_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Vec_int_3" "', argument " "2"" of type '" "cv::Matx< int,3,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_int_3" "', argument " "2"" of type '" "cv::Matx< int,3,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< int,3,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_AddOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Vec_int_3" "', argument " "3"" of type '" "cv::Matx_AddOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_int_3" "', argument " "3"" of type '" "cv::Matx_AddOp""'");
} else {
cv::Matx_AddOp * temp = reinterpret_cast< cv::Matx_AddOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Vec< int,3 > *)new cv::Vec< int,3 >((cv::Matx< int,3,1 > const &)*arg1,(cv::Matx< int,3,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__VecT_int_3_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Vec_int_3__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< int,3,1 > *arg1 = 0 ;
cv::Matx< int,3,1 > *arg2 = 0 ;
cv::Matx_SubOp 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 ;
cv::Vec< int,3 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Vec_int_3",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_int_3_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Vec_int_3" "', argument " "1"" of type '" "cv::Matx< int,3,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_int_3" "', argument " "1"" of type '" "cv::Matx< int,3,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< int,3,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_int_3_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Vec_int_3" "', argument " "2"" of type '" "cv::Matx< int,3,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_int_3" "', argument " "2"" of type '" "cv::Matx< int,3,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< int,3,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_SubOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Vec_int_3" "', argument " "3"" of type '" "cv::Matx_SubOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_int_3" "', argument " "3"" of type '" "cv::Matx_SubOp""'");
} else {
cv::Matx_SubOp * temp = reinterpret_cast< cv::Matx_SubOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Vec< int,3 > *)new cv::Vec< int,3 >((cv::Matx< int,3,1 > const &)*arg1,(cv::Matx< int,3,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__VecT_int_3_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Vec_int_3__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< cv::Vec< int,3 >::value_type,std::allocator< cv::Vec< int,3 >::value_type > > arg1 ;
PyObject * obj0 = 0 ;
cv::Vec< int,3 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__Vec_int_3",&obj0)) SWIG_fail;
{
std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
int res = swig::asptr(obj0, &ptr);
if (!SWIG_IsOK(res) || !ptr) {
SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new__Vec_int_3" "', argument " "1"" of type '" "std::vector< cv::Vec< int,3 >::value_type,std::allocator< cv::Vec< int,3 >::value_type > >""'");
}
arg1 = *ptr;
if (SWIG_IsNewObj(res)) delete ptr;
}
result = (cv::Vec< int,3 > *)new_cv_Vec_Sl_int_Sc_3_Sg___SWIG_4(arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__VecT_int_3_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Vec_int_3(PyObject *self, PyObject *args) {
Py_ssize_t argc;
PyObject *argv[4] = {
0
};
Py_ssize_t ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = args ? PyObject_Length(args) : 0;
for (ii = 0; (ii < 3) && (ii < argc); 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_int, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Vec_int_3__SWIG_0(self, args);
}
}
if (argc == 1) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__VecT_int_3_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Vec_int_3__SWIG_1(self, args);
}
}
if (argc == 1) {
int _v;
int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Vec_int_3__SWIG_4(self, args);
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_int_3_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_int_3_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_SubOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Vec_int_3__SWIG_3(self, args);
}
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_int_3_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_int_3_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_AddOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Vec_int_3__SWIG_2(self, args);
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new__Vec_int_3'.\n"
" Possible C/C++ prototypes are:\n"
" cv::Vec< int,3 >::Vec(int const *)\n"
" cv::Vec< int,3 >::Vec(cv::Vec< int,3 > const &)\n"
" cv::Vec< int,3 >::Vec(cv::Matx< int,3,1 > const &,cv::Matx< int,3,1 > const &,cv::Matx_AddOp)\n"
" cv::Vec< int,3 >::Vec(cv::Matx< int,3,1 > const &,cv::Matx< int,3,1 > const &,cv::Matx_SubOp)\n"
" cv::Vec< int,3 >::Vec(std::vector< cv::Vec< int,3 >::value_type,std::allocator< cv::Vec< int,3 >::value_type > >)\n");
return 0;
}
SWIGINTERN PyObject *_wrap__Vec_int_3___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Vec< int,3 > *arg1 = (cv::Vec< int,3 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
std::string result;
if (!PyArg_ParseTuple(args,(char *)"O:_Vec_int_3___str__",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__VecT_int_3_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Vec_int_3___str__" "', argument " "1"" of type '" "cv::Vec< int,3 > *""'");
}
arg1 = reinterpret_cast< cv::Vec< int,3 > * >(argp1);
result = cv_Vec_Sl_int_Sc_3_Sg____str__(arg1);
resultobj = SWIG_From_std_string(static_cast< std::string >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete__Vec_int_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Vec< int,3 > *arg1 = (cv::Vec< int,3 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete__Vec_int_3",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__VecT_int_3_t, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__Vec_int_3" "', argument " "1"" of type '" "cv::Vec< int,3 > *""'");
}
arg1 = reinterpret_cast< cv::Vec< int,3 > * >(argp1);
delete arg1;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_Vec_int_3_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_cv__VecT_int_3_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_new__DataType_Vec_int_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::DataType< cv::Vec< int,3 > > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new__DataType_Vec_int_3")) SWIG_fail;
result = (cv::DataType< cv::Vec< int,3 > > *)new cv::DataType< cv::Vec< int,3 > >();
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__DataTypeT_cv__VecT_int_3_t_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete__DataType_Vec_int_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::DataType< cv::Vec< int,3 > > *arg1 = (cv::DataType< cv::Vec< int,3 > > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete__DataType_Vec_int_3",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__DataTypeT_cv__VecT_int_3_t_t, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__DataType_Vec_int_3" "', argument " "1"" of type '" "cv::DataType< cv::Vec< int,3 > > *""'");
}
arg1 = reinterpret_cast< cv::DataType< cv::Vec< int,3 > > * >(argp1);
delete arg1;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_DataType_Vec_int_3_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_cv__DataTypeT_cv__VecT_int_3_t_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_new__Matx_int_4_1__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int *arg1 = (int *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
cv::Matx< int,4,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__Matx_int_4_1",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_int, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_int_4_1" "', argument " "1"" of type '" "int const *""'");
}
arg1 = reinterpret_cast< int * >(argp1);
result = (cv::Matx< int,4,1 > *)new cv::Matx< int,4,1 >((int const *)arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_int_4_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_int_4_1_all(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int val1 ;
int ecode1 = 0 ;
PyObject * obj0 = 0 ;
SwigValueWrapper< cv::Matx< int,4,1 > > result;
if (!PyArg_ParseTuple(args,(char *)"O:_Matx_int_4_1_all",&obj0)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_Matx_int_4_1_all" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
result = cv::Matx< int,4,1 >::SWIGTEMPLATEDISAMBIGUATOR all(arg1);
resultobj = SWIG_NewPointerObj((new cv::Matx< int,4,1 >(static_cast< const cv::Matx< int,4,1 >& >(result))), SWIGTYPE_p_cv__MatxT_int_4_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_int_4_1_zeros(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
SwigValueWrapper< cv::Matx< int,4,1 > > result;
if (!PyArg_ParseTuple(args,(char *)":_Matx_int_4_1_zeros")) SWIG_fail;
result = cv::Matx< int,4,1 >::SWIGTEMPLATEDISAMBIGUATOR zeros();
resultobj = SWIG_NewPointerObj((new cv::Matx< int,4,1 >(static_cast< const cv::Matx< int,4,1 >& >(result))), SWIGTYPE_p_cv__MatxT_int_4_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_int_4_1_ones(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
SwigValueWrapper< cv::Matx< int,4,1 > > result;
if (!PyArg_ParseTuple(args,(char *)":_Matx_int_4_1_ones")) SWIG_fail;
result = cv::Matx< int,4,1 >::SWIGTEMPLATEDISAMBIGUATOR ones();
resultobj = SWIG_NewPointerObj((new cv::Matx< int,4,1 >(static_cast< const cv::Matx< int,4,1 >& >(result))), SWIGTYPE_p_cv__MatxT_int_4_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_int_4_1_eye(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
SwigValueWrapper< cv::Matx< int,4,1 > > result;
if (!PyArg_ParseTuple(args,(char *)":_Matx_int_4_1_eye")) SWIG_fail;
result = cv::Matx< int,4,1 >::SWIGTEMPLATEDISAMBIGUATOR eye();
resultobj = SWIG_NewPointerObj((new cv::Matx< int,4,1 >(static_cast< const cv::Matx< int,4,1 >& >(result))), SWIGTYPE_p_cv__MatxT_int_4_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_int_4_1_randu(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 ;
SwigValueWrapper< cv::Matx< int,4,1 > > result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_int_4_1_randu",&obj0,&obj1)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_Matx_int_4_1_randu" "', 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 '" "_Matx_int_4_1_randu" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
result = cv::Matx< int,4,1 >::SWIGTEMPLATEDISAMBIGUATOR randu(arg1,arg2);
resultobj = SWIG_NewPointerObj((new cv::Matx< int,4,1 >(static_cast< const cv::Matx< int,4,1 >& >(result))), SWIGTYPE_p_cv__MatxT_int_4_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_int_4_1_randn(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 ;
SwigValueWrapper< cv::Matx< int,4,1 > > result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_int_4_1_randn",&obj0,&obj1)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_Matx_int_4_1_randn" "', 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 '" "_Matx_int_4_1_randn" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
result = cv::Matx< int,4,1 >::SWIGTEMPLATEDISAMBIGUATOR randn(arg1,arg2);
resultobj = SWIG_NewPointerObj((new cv::Matx< int,4,1 >(static_cast< const cv::Matx< int,4,1 >& >(result))), SWIGTYPE_p_cv__MatxT_int_4_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_int_4_1_dot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< int,4,1 > *arg1 = (cv::Matx< int,4,1 > *) 0 ;
cv::Matx< int,4,1 > *arg2 = 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:_Matx_int_4_1_dot",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_int_4_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_int_4_1_dot" "', argument " "1"" of type '" "cv::Matx< int,4,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< int,4,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_int_4_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_int_4_1_dot" "', argument " "2"" of type '" "cv::Matx< int,4,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Matx_int_4_1_dot" "', argument " "2"" of type '" "cv::Matx< int,4,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< int,4,1 > * >(argp2);
result = (int)((cv::Matx< int,4,1 > const *)arg1)->dot((cv::Matx< int,4,1 > const &)*arg2);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_int_4_1_ddot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< int,4,1 > *arg1 = (cv::Matx< int,4,1 > *) 0 ;
cv::Matx< int,4,1 > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
double result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_int_4_1_ddot",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_int_4_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_int_4_1_ddot" "', argument " "1"" of type '" "cv::Matx< int,4,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< int,4,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_int_4_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_int_4_1_ddot" "', argument " "2"" of type '" "cv::Matx< int,4,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Matx_int_4_1_ddot" "', argument " "2"" of type '" "cv::Matx< int,4,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< int,4,1 > * >(argp2);
result = (double)((cv::Matx< int,4,1 > const *)arg1)->ddot((cv::Matx< int,4,1 > const &)*arg2);
resultobj = SWIG_From_double(static_cast< double >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_int_4_1_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< int,4,1 > *arg1 = (cv::Matx< int,4,1 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
SwigValueWrapper< cv::Matx< int,1,4 > > result;
if (!PyArg_ParseTuple(args,(char *)"O:_Matx_int_4_1_t",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_int_4_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_int_4_1_t" "', argument " "1"" of type '" "cv::Matx< int,4,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< int,4,1 > * >(argp1);
result = ((cv::Matx< int,4,1 > const *)arg1)->t();
resultobj = SWIG_NewPointerObj((new cv::Matx< int,1,4 >(static_cast< const cv::Matx< int,1,4 >& >(result))), SWIGTYPE_p_cv__MatxT_int_1_4_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_int_4_1_mul(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< int,4,1 > *arg1 = (cv::Matx< int,4,1 > *) 0 ;
cv::Matx< int,4,1 > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
SwigValueWrapper< cv::Matx< int,4,1 > > result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_int_4_1_mul",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_int_4_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_int_4_1_mul" "', argument " "1"" of type '" "cv::Matx< int,4,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< int,4,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_int_4_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_int_4_1_mul" "', argument " "2"" of type '" "cv::Matx< int,4,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Matx_int_4_1_mul" "', argument " "2"" of type '" "cv::Matx< int,4,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< int,4,1 > * >(argp2);
result = ((cv::Matx< int,4,1 > const *)arg1)->mul((cv::Matx< int,4,1 > const &)*arg2);
resultobj = SWIG_NewPointerObj((new cv::Matx< int,4,1 >(static_cast< const cv::Matx< int,4,1 >& >(result))), SWIGTYPE_p_cv__MatxT_int_4_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_int_4_1_div(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< int,4,1 > *arg1 = (cv::Matx< int,4,1 > *) 0 ;
cv::Matx< int,4,1 > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
SwigValueWrapper< cv::Matx< int,4,1 > > result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_int_4_1_div",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_int_4_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_int_4_1_div" "', argument " "1"" of type '" "cv::Matx< int,4,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< int,4,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_int_4_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_int_4_1_div" "', argument " "2"" of type '" "cv::Matx< int,4,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Matx_int_4_1_div" "', argument " "2"" of type '" "cv::Matx< int,4,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< int,4,1 > * >(argp2);
result = ((cv::Matx< int,4,1 > const *)arg1)->div((cv::Matx< int,4,1 > const &)*arg2);
resultobj = SWIG_NewPointerObj((new cv::Matx< int,4,1 >(static_cast< const cv::Matx< int,4,1 >& >(result))), SWIGTYPE_p_cv__MatxT_int_4_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_int_4_1___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< int,4,1 > *arg1 = (cv::Matx< int,4,1 > *) 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 ;
int *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:_Matx_int_4_1___call__",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_int_4_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_int_4_1___call__" "', argument " "1"" of type '" "cv::Matx< int,4,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< int,4,1 > * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_Matx_int_4_1___call__" "', 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 '" "_Matx_int_4_1___call__" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
result = (int *) &((cv::Matx< int,4,1 > const *)arg1)->operator ()(arg2,arg3);
resultobj = SWIG_From_int(static_cast< int >(*result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_int_4_1__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< int,4,1 > *arg1 = 0 ;
cv::Matx< int,4,1 > *arg2 = 0 ;
cv::Matx_AddOp 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 ;
cv::Matx< int,4,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Matx_int_4_1",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_int_4_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_int_4_1" "', argument " "1"" of type '" "cv::Matx< int,4,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_int_4_1" "', argument " "1"" of type '" "cv::Matx< int,4,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< int,4,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_int_4_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Matx_int_4_1" "', argument " "2"" of type '" "cv::Matx< int,4,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_int_4_1" "', argument " "2"" of type '" "cv::Matx< int,4,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< int,4,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_AddOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Matx_int_4_1" "', argument " "3"" of type '" "cv::Matx_AddOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_int_4_1" "', argument " "3"" of type '" "cv::Matx_AddOp""'");
} else {
cv::Matx_AddOp * temp = reinterpret_cast< cv::Matx_AddOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Matx< int,4,1 > *)new cv::Matx< int,4,1 >((cv::Matx< int,4,1 > const &)*arg1,(cv::Matx< int,4,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_int_4_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_int_4_1__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< int,4,1 > *arg1 = 0 ;
cv::Matx< int,4,1 > *arg2 = 0 ;
cv::Matx_SubOp 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 ;
cv::Matx< int,4,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Matx_int_4_1",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_int_4_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_int_4_1" "', argument " "1"" of type '" "cv::Matx< int,4,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_int_4_1" "', argument " "1"" of type '" "cv::Matx< int,4,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< int,4,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_int_4_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Matx_int_4_1" "', argument " "2"" of type '" "cv::Matx< int,4,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_int_4_1" "', argument " "2"" of type '" "cv::Matx< int,4,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< int,4,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_SubOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Matx_int_4_1" "', argument " "3"" of type '" "cv::Matx_SubOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_int_4_1" "', argument " "3"" of type '" "cv::Matx_SubOp""'");
} else {
cv::Matx_SubOp * temp = reinterpret_cast< cv::Matx_SubOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Matx< int,4,1 > *)new cv::Matx< int,4,1 >((cv::Matx< int,4,1 > const &)*arg1,(cv::Matx< int,4,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_int_4_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_int_4_1__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< int,4,1 > *arg1 = 0 ;
cv::Matx< int,4,1 > *arg2 = 0 ;
cv::Matx_MulOp 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 ;
cv::Matx< int,4,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Matx_int_4_1",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_int_4_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_int_4_1" "', argument " "1"" of type '" "cv::Matx< int,4,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_int_4_1" "', argument " "1"" of type '" "cv::Matx< int,4,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< int,4,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_int_4_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Matx_int_4_1" "', argument " "2"" of type '" "cv::Matx< int,4,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_int_4_1" "', argument " "2"" of type '" "cv::Matx< int,4,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< int,4,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_MulOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Matx_int_4_1" "', argument " "3"" of type '" "cv::Matx_MulOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_int_4_1" "', argument " "3"" of type '" "cv::Matx_MulOp""'");
} else {
cv::Matx_MulOp * temp = reinterpret_cast< cv::Matx_MulOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Matx< int,4,1 > *)new cv::Matx< int,4,1 >((cv::Matx< int,4,1 > const &)*arg1,(cv::Matx< int,4,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_int_4_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_int_4_1__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< int,4,1 > *arg1 = 0 ;
cv::Matx< int,4,1 > *arg2 = 0 ;
cv::Matx_DivOp 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 ;
cv::Matx< int,4,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Matx_int_4_1",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_int_4_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_int_4_1" "', argument " "1"" of type '" "cv::Matx< int,4,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_int_4_1" "', argument " "1"" of type '" "cv::Matx< int,4,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< int,4,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_int_4_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Matx_int_4_1" "', argument " "2"" of type '" "cv::Matx< int,4,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_int_4_1" "', argument " "2"" of type '" "cv::Matx< int,4,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< int,4,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_DivOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Matx_int_4_1" "', argument " "3"" of type '" "cv::Matx_DivOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_int_4_1" "', argument " "3"" of type '" "cv::Matx_DivOp""'");
} else {
cv::Matx_DivOp * temp = reinterpret_cast< cv::Matx_DivOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Matx< int,4,1 > *)new cv::Matx< int,4,1 >((cv::Matx< int,4,1 > const &)*arg1,(cv::Matx< int,4,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_int_4_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_int_4_1__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< int,1,4 > *arg1 = 0 ;
cv::Matx_TOp arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
cv::Matx< int,4,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:new__Matx_int_4_1",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_int_1_4_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_int_4_1" "', argument " "1"" of type '" "cv::Matx< int,1,4 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_int_4_1" "', argument " "1"" of type '" "cv::Matx< int,1,4 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< int,1,4 > * >(argp1);
{
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__Matx_TOp, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Matx_int_4_1" "', argument " "2"" of type '" "cv::Matx_TOp""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_int_4_1" "', argument " "2"" of type '" "cv::Matx_TOp""'");
} else {
cv::Matx_TOp * temp = reinterpret_cast< cv::Matx_TOp * >(argp2);
arg2 = *temp;
if (SWIG_IsNewObj(res2)) delete temp;
}
}
result = (cv::Matx< int,4,1 > *)new cv::Matx< int,4,1 >((cv::Matx< int,1,4 > const &)*arg1,arg2);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_int_4_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_int_4_1_val_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< int,4,1 > *arg1 = (cv::Matx< int,4,1 > *) 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:_Matx_int_4_1_val_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_int_4_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_int_4_1_val_set" "', argument " "1"" of type '" "cv::Matx< int,4,1 > *""'");
}
arg1 = reinterpret_cast< cv::Matx< int,4,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_int, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_int_4_1_val_set" "', argument " "2"" of type '" "int [4*1]""'");
}
arg2 = reinterpret_cast< int * >(argp2);
{
if (arg2) {
size_t ii = 0;
for (; ii < (size_t)4*1; ++ii) *(int *)&arg1->val[ii] = *((int *)arg2 + ii);
} else {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""val""' of type '""int [4*1]""'");
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_int_4_1_val_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< int,4,1 > *arg1 = (cv::Matx< int,4,1 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:_Matx_int_4_1_val_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_int_4_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_int_4_1_val_get" "', argument " "1"" of type '" "cv::Matx< int,4,1 > *""'");
}
arg1 = reinterpret_cast< cv::Matx< int,4,1 > * >(argp1);
result = (int *)(int *) ((arg1)->val);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_int_4_1__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< cv::Matx< int,4,1 >::value_type,std::allocator< cv::Matx< int,4,1 >::value_type > > arg1 ;
PyObject * obj0 = 0 ;
cv::Matx< int,4,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__Matx_int_4_1",&obj0)) SWIG_fail;
{
std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
int res = swig::asptr(obj0, &ptr);
if (!SWIG_IsOK(res) || !ptr) {
SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new__Matx_int_4_1" "', argument " "1"" of type '" "std::vector< cv::Matx< int,4,1 >::value_type,std::allocator< cv::Matx< int,4,1 >::value_type > >""'");
}
arg1 = *ptr;
if (SWIG_IsNewObj(res)) delete ptr;
}
result = (cv::Matx< int,4,1 > *)new_cv_Matx_Sl_int_Sc_4_Sc_1_Sg___SWIG_6(arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_int_4_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_int_4_1(PyObject *self, PyObject *args) {
Py_ssize_t argc;
PyObject *argv[4] = {
0
};
Py_ssize_t ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = args ? PyObject_Length(args) : 0;
for (ii = 0; (ii < 3) && (ii < argc); 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_int, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_int_4_1__SWIG_0(self, args);
}
}
if (argc == 1) {
int _v;
int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_int_4_1__SWIG_6(self, args);
}
}
if (argc == 2) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_int_1_4_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__Matx_TOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_int_4_1__SWIG_5(self, args);
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_int_4_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_int_4_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_MulOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_int_4_1__SWIG_3(self, args);
}
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_int_4_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_int_4_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_DivOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_int_4_1__SWIG_4(self, args);
}
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_int_4_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_int_4_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_AddOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_int_4_1__SWIG_1(self, args);
}
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_int_4_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_int_4_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_SubOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_int_4_1__SWIG_2(self, args);
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new__Matx_int_4_1'.\n"
" Possible C/C++ prototypes are:\n"
" cv::Matx< int,4,1 >::Matx(int const *)\n"
" cv::Matx< int,4,1 >::Matx(cv::Matx< int,4,1 > const &,cv::Matx< int,4,1 > const &,cv::Matx_AddOp)\n"
" cv::Matx< int,4,1 >::Matx(cv::Matx< int,4,1 > const &,cv::Matx< int,4,1 > const &,cv::Matx_SubOp)\n"
" cv::Matx< int,4,1 >::Matx(cv::Matx< int,4,1 > const &,cv::Matx< int,4,1 > const &,cv::Matx_MulOp)\n"
" cv::Matx< int,4,1 >::Matx(cv::Matx< int,4,1 > const &,cv::Matx< int,4,1 > const &,cv::Matx_DivOp)\n"
" cv::Matx< int,4,1 >::Matx(cv::Matx< int,1,4 > const &,cv::Matx_TOp)\n"
" cv::Matx< int,4,1 >::Matx(std::vector< cv::Matx< int,4,1 >::value_type,std::allocator< cv::Matx< int,4,1 >::value_type > >)\n");
return 0;
}
SWIGINTERN PyObject *_wrap__Matx_int_4_1___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< int,4,1 > *arg1 = (cv::Matx< int,4,1 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
std::string result;
if (!PyArg_ParseTuple(args,(char *)"O:_Matx_int_4_1___str__",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_int_4_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_int_4_1___str__" "', argument " "1"" of type '" "cv::Matx< int,4,1 > *""'");
}
arg1 = reinterpret_cast< cv::Matx< int,4,1 > * >(argp1);
result = cv_Matx_Sl_int_Sc_4_Sc_1_Sg____str__(arg1);
resultobj = SWIG_From_std_string(static_cast< std::string >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete__Matx_int_4_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< int,4,1 > *arg1 = (cv::Matx< int,4,1 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete__Matx_int_4_1",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_int_4_1_t, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__Matx_int_4_1" "', argument " "1"" of type '" "cv::Matx< int,4,1 > *""'");
}
arg1 = reinterpret_cast< cv::Matx< int,4,1 > * >(argp1);
delete arg1;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_Matx_int_4_1_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_cv__MatxT_int_4_1_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_new__Vec_int_4__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int *arg1 = (int *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
cv::Vec< int,4 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__Vec_int_4",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_int, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Vec_int_4" "', argument " "1"" of type '" "int const *""'");
}
arg1 = reinterpret_cast< int * >(argp1);
result = (cv::Vec< int,4 > *)new cv::Vec< int,4 >((int const *)arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__VecT_int_4_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Vec_int_4__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Vec< int,4 > *arg1 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
cv::Vec< int,4 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__Vec_int_4",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__VecT_int_4_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Vec_int_4" "', argument " "1"" of type '" "cv::Vec< int,4 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_int_4" "', argument " "1"" of type '" "cv::Vec< int,4 > const &""'");
}
arg1 = reinterpret_cast< cv::Vec< int,4 > * >(argp1);
result = (cv::Vec< int,4 > *)new cv::Vec< int,4 >((cv::Vec< int,4 > const &)*arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__VecT_int_4_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Vec_int_4_all(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int val1 ;
int ecode1 = 0 ;
PyObject * obj0 = 0 ;
SwigValueWrapper< cv::Vec< int,4 > > result;
if (!PyArg_ParseTuple(args,(char *)"O:_Vec_int_4_all",&obj0)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_Vec_int_4_all" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
result = cv::Vec< int,4 >::SWIGTEMPLATEDISAMBIGUATOR all(arg1);
resultobj = SWIG_NewPointerObj((new cv::Vec< int,4 >(static_cast< const cv::Vec< int,4 >& >(result))), SWIGTYPE_p_cv__VecT_int_4_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Vec_int_4_mul(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Vec< int,4 > *arg1 = (cv::Vec< int,4 > *) 0 ;
cv::Vec< int,4 > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
SwigValueWrapper< cv::Vec< int,4 > > result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Vec_int_4_mul",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__VecT_int_4_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Vec_int_4_mul" "', argument " "1"" of type '" "cv::Vec< int,4 > const *""'");
}
arg1 = reinterpret_cast< cv::Vec< int,4 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__VecT_int_4_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Vec_int_4_mul" "', argument " "2"" of type '" "cv::Vec< int,4 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Vec_int_4_mul" "', argument " "2"" of type '" "cv::Vec< int,4 > const &""'");
}
arg2 = reinterpret_cast< cv::Vec< int,4 > * >(argp2);
result = ((cv::Vec< int,4 > const *)arg1)->mul((cv::Vec< int,4 > const &)*arg2);
resultobj = SWIG_NewPointerObj((new cv::Vec< int,4 >(static_cast< const cv::Vec< int,4 >& >(result))), SWIGTYPE_p_cv__VecT_int_4_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Vec_int_4___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Vec< int,4 > *arg1 = (cv::Vec< int,4 > *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
int *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:_Vec_int_4___call__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__VecT_int_4_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Vec_int_4___call__" "', argument " "1"" of type '" "cv::Vec< int,4 > const *""'");
}
arg1 = reinterpret_cast< cv::Vec< int,4 > * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_Vec_int_4___call__" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
result = (int *) &((cv::Vec< int,4 > const *)arg1)->operator ()(arg2);
resultobj = SWIG_From_int(static_cast< int >(*result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Vec_int_4__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< int,4,1 > *arg1 = 0 ;
cv::Matx< int,4,1 > *arg2 = 0 ;
cv::Matx_AddOp 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 ;
cv::Vec< int,4 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Vec_int_4",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_int_4_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Vec_int_4" "', argument " "1"" of type '" "cv::Matx< int,4,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_int_4" "', argument " "1"" of type '" "cv::Matx< int,4,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< int,4,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_int_4_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Vec_int_4" "', argument " "2"" of type '" "cv::Matx< int,4,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_int_4" "', argument " "2"" of type '" "cv::Matx< int,4,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< int,4,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_AddOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Vec_int_4" "', argument " "3"" of type '" "cv::Matx_AddOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_int_4" "', argument " "3"" of type '" "cv::Matx_AddOp""'");
} else {
cv::Matx_AddOp * temp = reinterpret_cast< cv::Matx_AddOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Vec< int,4 > *)new cv::Vec< int,4 >((cv::Matx< int,4,1 > const &)*arg1,(cv::Matx< int,4,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__VecT_int_4_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Vec_int_4__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< int,4,1 > *arg1 = 0 ;
cv::Matx< int,4,1 > *arg2 = 0 ;
cv::Matx_SubOp 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 ;
cv::Vec< int,4 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Vec_int_4",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_int_4_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Vec_int_4" "', argument " "1"" of type '" "cv::Matx< int,4,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_int_4" "', argument " "1"" of type '" "cv::Matx< int,4,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< int,4,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_int_4_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Vec_int_4" "', argument " "2"" of type '" "cv::Matx< int,4,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_int_4" "', argument " "2"" of type '" "cv::Matx< int,4,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< int,4,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_SubOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Vec_int_4" "', argument " "3"" of type '" "cv::Matx_SubOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_int_4" "', argument " "3"" of type '" "cv::Matx_SubOp""'");
} else {
cv::Matx_SubOp * temp = reinterpret_cast< cv::Matx_SubOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Vec< int,4 > *)new cv::Vec< int,4 >((cv::Matx< int,4,1 > const &)*arg1,(cv::Matx< int,4,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__VecT_int_4_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Vec_int_4__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< cv::Vec< int,4 >::value_type,std::allocator< cv::Vec< int,4 >::value_type > > arg1 ;
PyObject * obj0 = 0 ;
cv::Vec< int,4 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__Vec_int_4",&obj0)) SWIG_fail;
{
std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
int res = swig::asptr(obj0, &ptr);
if (!SWIG_IsOK(res) || !ptr) {
SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new__Vec_int_4" "', argument " "1"" of type '" "std::vector< cv::Vec< int,4 >::value_type,std::allocator< cv::Vec< int,4 >::value_type > >""'");
}
arg1 = *ptr;
if (SWIG_IsNewObj(res)) delete ptr;
}
result = (cv::Vec< int,4 > *)new_cv_Vec_Sl_int_Sc_4_Sg___SWIG_4(arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__VecT_int_4_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Vec_int_4(PyObject *self, PyObject *args) {
Py_ssize_t argc;
PyObject *argv[4] = {
0
};
Py_ssize_t ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = args ? PyObject_Length(args) : 0;
for (ii = 0; (ii < 3) && (ii < argc); 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_int, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Vec_int_4__SWIG_0(self, args);
}
}
if (argc == 1) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__VecT_int_4_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Vec_int_4__SWIG_1(self, args);
}
}
if (argc == 1) {
int _v;
int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Vec_int_4__SWIG_4(self, args);
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_int_4_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_int_4_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_SubOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Vec_int_4__SWIG_3(self, args);
}
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_int_4_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_int_4_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_AddOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Vec_int_4__SWIG_2(self, args);
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new__Vec_int_4'.\n"
" Possible C/C++ prototypes are:\n"
" cv::Vec< int,4 >::Vec(int const *)\n"
" cv::Vec< int,4 >::Vec(cv::Vec< int,4 > const &)\n"
" cv::Vec< int,4 >::Vec(cv::Matx< int,4,1 > const &,cv::Matx< int,4,1 > const &,cv::Matx_AddOp)\n"
" cv::Vec< int,4 >::Vec(cv::Matx< int,4,1 > const &,cv::Matx< int,4,1 > const &,cv::Matx_SubOp)\n"
" cv::Vec< int,4 >::Vec(std::vector< cv::Vec< int,4 >::value_type,std::allocator< cv::Vec< int,4 >::value_type > >)\n");
return 0;
}
SWIGINTERN PyObject *_wrap__Vec_int_4___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Vec< int,4 > *arg1 = (cv::Vec< int,4 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
std::string result;
if (!PyArg_ParseTuple(args,(char *)"O:_Vec_int_4___str__",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__VecT_int_4_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Vec_int_4___str__" "', argument " "1"" of type '" "cv::Vec< int,4 > *""'");
}
arg1 = reinterpret_cast< cv::Vec< int,4 > * >(argp1);
result = cv_Vec_Sl_int_Sc_4_Sg____str__(arg1);
resultobj = SWIG_From_std_string(static_cast< std::string >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete__Vec_int_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Vec< int,4 > *arg1 = (cv::Vec< int,4 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete__Vec_int_4",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__VecT_int_4_t, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__Vec_int_4" "', argument " "1"" of type '" "cv::Vec< int,4 > *""'");
}
arg1 = reinterpret_cast< cv::Vec< int,4 > * >(argp1);
delete arg1;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_Vec_int_4_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_cv__VecT_int_4_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_new__DataType_Vec_int_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::DataType< cv::Vec< int,4 > > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new__DataType_Vec_int_4")) SWIG_fail;
result = (cv::DataType< cv::Vec< int,4 > > *)new cv::DataType< cv::Vec< int,4 > >();
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__DataTypeT_cv__VecT_int_4_t_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete__DataType_Vec_int_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::DataType< cv::Vec< int,4 > > *arg1 = (cv::DataType< cv::Vec< int,4 > > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete__DataType_Vec_int_4",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__DataTypeT_cv__VecT_int_4_t_t, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__DataType_Vec_int_4" "', argument " "1"" of type '" "cv::DataType< cv::Vec< int,4 > > *""'");
}
arg1 = reinterpret_cast< cv::DataType< cv::Vec< int,4 > > * >(argp1);
delete arg1;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_DataType_Vec_int_4_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_cv__DataTypeT_cv__VecT_int_4_t_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_new__Matx_int_6_1__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int *arg1 = (int *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
cv::Matx< int,6,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__Matx_int_6_1",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_int, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_int_6_1" "', argument " "1"" of type '" "int const *""'");
}
arg1 = reinterpret_cast< int * >(argp1);
result = (cv::Matx< int,6,1 > *)new cv::Matx< int,6,1 >((int const *)arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_int_6_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_int_6_1_all(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int val1 ;
int ecode1 = 0 ;
PyObject * obj0 = 0 ;
SwigValueWrapper< cv::Matx< int,6,1 > > result;
if (!PyArg_ParseTuple(args,(char *)"O:_Matx_int_6_1_all",&obj0)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_Matx_int_6_1_all" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
result = cv::Matx< int,6,1 >::SWIGTEMPLATEDISAMBIGUATOR all(arg1);
resultobj = SWIG_NewPointerObj((new cv::Matx< int,6,1 >(static_cast< const cv::Matx< int,6,1 >& >(result))), SWIGTYPE_p_cv__MatxT_int_6_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_int_6_1_zeros(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
SwigValueWrapper< cv::Matx< int,6,1 > > result;
if (!PyArg_ParseTuple(args,(char *)":_Matx_int_6_1_zeros")) SWIG_fail;
result = cv::Matx< int,6,1 >::SWIGTEMPLATEDISAMBIGUATOR zeros();
resultobj = SWIG_NewPointerObj((new cv::Matx< int,6,1 >(static_cast< const cv::Matx< int,6,1 >& >(result))), SWIGTYPE_p_cv__MatxT_int_6_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_int_6_1_ones(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
SwigValueWrapper< cv::Matx< int,6,1 > > result;
if (!PyArg_ParseTuple(args,(char *)":_Matx_int_6_1_ones")) SWIG_fail;
result = cv::Matx< int,6,1 >::SWIGTEMPLATEDISAMBIGUATOR ones();
resultobj = SWIG_NewPointerObj((new cv::Matx< int,6,1 >(static_cast< const cv::Matx< int,6,1 >& >(result))), SWIGTYPE_p_cv__MatxT_int_6_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_int_6_1_eye(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
SwigValueWrapper< cv::Matx< int,6,1 > > result;
if (!PyArg_ParseTuple(args,(char *)":_Matx_int_6_1_eye")) SWIG_fail;
result = cv::Matx< int,6,1 >::SWIGTEMPLATEDISAMBIGUATOR eye();
resultobj = SWIG_NewPointerObj((new cv::Matx< int,6,1 >(static_cast< const cv::Matx< int,6,1 >& >(result))), SWIGTYPE_p_cv__MatxT_int_6_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_int_6_1_randu(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 ;
SwigValueWrapper< cv::Matx< int,6,1 > > result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_int_6_1_randu",&obj0,&obj1)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_Matx_int_6_1_randu" "', 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 '" "_Matx_int_6_1_randu" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
result = cv::Matx< int,6,1 >::SWIGTEMPLATEDISAMBIGUATOR randu(arg1,arg2);
resultobj = SWIG_NewPointerObj((new cv::Matx< int,6,1 >(static_cast< const cv::Matx< int,6,1 >& >(result))), SWIGTYPE_p_cv__MatxT_int_6_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_int_6_1_randn(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 ;
SwigValueWrapper< cv::Matx< int,6,1 > > result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_int_6_1_randn",&obj0,&obj1)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_Matx_int_6_1_randn" "', 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 '" "_Matx_int_6_1_randn" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
result = cv::Matx< int,6,1 >::SWIGTEMPLATEDISAMBIGUATOR randn(arg1,arg2);
resultobj = SWIG_NewPointerObj((new cv::Matx< int,6,1 >(static_cast< const cv::Matx< int,6,1 >& >(result))), SWIGTYPE_p_cv__MatxT_int_6_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_int_6_1_dot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< int,6,1 > *arg1 = (cv::Matx< int,6,1 > *) 0 ;
cv::Matx< int,6,1 > *arg2 = 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:_Matx_int_6_1_dot",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_int_6_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_int_6_1_dot" "', argument " "1"" of type '" "cv::Matx< int,6,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< int,6,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_int_6_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_int_6_1_dot" "', argument " "2"" of type '" "cv::Matx< int,6,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Matx_int_6_1_dot" "', argument " "2"" of type '" "cv::Matx< int,6,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< int,6,1 > * >(argp2);
result = (int)((cv::Matx< int,6,1 > const *)arg1)->dot((cv::Matx< int,6,1 > const &)*arg2);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_int_6_1_ddot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< int,6,1 > *arg1 = (cv::Matx< int,6,1 > *) 0 ;
cv::Matx< int,6,1 > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
double result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_int_6_1_ddot",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_int_6_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_int_6_1_ddot" "', argument " "1"" of type '" "cv::Matx< int,6,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< int,6,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_int_6_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_int_6_1_ddot" "', argument " "2"" of type '" "cv::Matx< int,6,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Matx_int_6_1_ddot" "', argument " "2"" of type '" "cv::Matx< int,6,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< int,6,1 > * >(argp2);
result = (double)((cv::Matx< int,6,1 > const *)arg1)->ddot((cv::Matx< int,6,1 > const &)*arg2);
resultobj = SWIG_From_double(static_cast< double >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_int_6_1_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< int,6,1 > *arg1 = (cv::Matx< int,6,1 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
SwigValueWrapper< cv::Matx< int,1,6 > > result;
if (!PyArg_ParseTuple(args,(char *)"O:_Matx_int_6_1_t",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_int_6_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_int_6_1_t" "', argument " "1"" of type '" "cv::Matx< int,6,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< int,6,1 > * >(argp1);
result = ((cv::Matx< int,6,1 > const *)arg1)->t();
resultobj = SWIG_NewPointerObj((new cv::Matx< int,1,6 >(static_cast< const cv::Matx< int,1,6 >& >(result))), SWIGTYPE_p_cv__MatxT_int_1_6_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_int_6_1_mul(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< int,6,1 > *arg1 = (cv::Matx< int,6,1 > *) 0 ;
cv::Matx< int,6,1 > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
SwigValueWrapper< cv::Matx< int,6,1 > > result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_int_6_1_mul",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_int_6_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_int_6_1_mul" "', argument " "1"" of type '" "cv::Matx< int,6,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< int,6,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_int_6_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_int_6_1_mul" "', argument " "2"" of type '" "cv::Matx< int,6,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Matx_int_6_1_mul" "', argument " "2"" of type '" "cv::Matx< int,6,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< int,6,1 > * >(argp2);
result = ((cv::Matx< int,6,1 > const *)arg1)->mul((cv::Matx< int,6,1 > const &)*arg2);
resultobj = SWIG_NewPointerObj((new cv::Matx< int,6,1 >(static_cast< const cv::Matx< int,6,1 >& >(result))), SWIGTYPE_p_cv__MatxT_int_6_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_int_6_1_div(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< int,6,1 > *arg1 = (cv::Matx< int,6,1 > *) 0 ;
cv::Matx< int,6,1 > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
SwigValueWrapper< cv::Matx< int,6,1 > > result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_int_6_1_div",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_int_6_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_int_6_1_div" "', argument " "1"" of type '" "cv::Matx< int,6,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< int,6,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_int_6_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_int_6_1_div" "', argument " "2"" of type '" "cv::Matx< int,6,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Matx_int_6_1_div" "', argument " "2"" of type '" "cv::Matx< int,6,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< int,6,1 > * >(argp2);
result = ((cv::Matx< int,6,1 > const *)arg1)->div((cv::Matx< int,6,1 > const &)*arg2);
resultobj = SWIG_NewPointerObj((new cv::Matx< int,6,1 >(static_cast< const cv::Matx< int,6,1 >& >(result))), SWIGTYPE_p_cv__MatxT_int_6_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_int_6_1___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< int,6,1 > *arg1 = (cv::Matx< int,6,1 > *) 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 ;
int *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:_Matx_int_6_1___call__",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_int_6_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_int_6_1___call__" "', argument " "1"" of type '" "cv::Matx< int,6,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< int,6,1 > * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_Matx_int_6_1___call__" "', 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 '" "_Matx_int_6_1___call__" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
result = (int *) &((cv::Matx< int,6,1 > const *)arg1)->operator ()(arg2,arg3);
resultobj = SWIG_From_int(static_cast< int >(*result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_int_6_1__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< int,6,1 > *arg1 = 0 ;
cv::Matx< int,6,1 > *arg2 = 0 ;
cv::Matx_AddOp 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 ;
cv::Matx< int,6,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Matx_int_6_1",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_int_6_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_int_6_1" "', argument " "1"" of type '" "cv::Matx< int,6,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_int_6_1" "', argument " "1"" of type '" "cv::Matx< int,6,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< int,6,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_int_6_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Matx_int_6_1" "', argument " "2"" of type '" "cv::Matx< int,6,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_int_6_1" "', argument " "2"" of type '" "cv::Matx< int,6,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< int,6,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_AddOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Matx_int_6_1" "', argument " "3"" of type '" "cv::Matx_AddOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_int_6_1" "', argument " "3"" of type '" "cv::Matx_AddOp""'");
} else {
cv::Matx_AddOp * temp = reinterpret_cast< cv::Matx_AddOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Matx< int,6,1 > *)new cv::Matx< int,6,1 >((cv::Matx< int,6,1 > const &)*arg1,(cv::Matx< int,6,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_int_6_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_int_6_1__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< int,6,1 > *arg1 = 0 ;
cv::Matx< int,6,1 > *arg2 = 0 ;
cv::Matx_SubOp 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 ;
cv::Matx< int,6,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Matx_int_6_1",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_int_6_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_int_6_1" "', argument " "1"" of type '" "cv::Matx< int,6,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_int_6_1" "', argument " "1"" of type '" "cv::Matx< int,6,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< int,6,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_int_6_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Matx_int_6_1" "', argument " "2"" of type '" "cv::Matx< int,6,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_int_6_1" "', argument " "2"" of type '" "cv::Matx< int,6,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< int,6,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_SubOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Matx_int_6_1" "', argument " "3"" of type '" "cv::Matx_SubOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_int_6_1" "', argument " "3"" of type '" "cv::Matx_SubOp""'");
} else {
cv::Matx_SubOp * temp = reinterpret_cast< cv::Matx_SubOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Matx< int,6,1 > *)new cv::Matx< int,6,1 >((cv::Matx< int,6,1 > const &)*arg1,(cv::Matx< int,6,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_int_6_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_int_6_1__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< int,6,1 > *arg1 = 0 ;
cv::Matx< int,6,1 > *arg2 = 0 ;
cv::Matx_MulOp 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 ;
cv::Matx< int,6,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Matx_int_6_1",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_int_6_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_int_6_1" "', argument " "1"" of type '" "cv::Matx< int,6,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_int_6_1" "', argument " "1"" of type '" "cv::Matx< int,6,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< int,6,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_int_6_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Matx_int_6_1" "', argument " "2"" of type '" "cv::Matx< int,6,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_int_6_1" "', argument " "2"" of type '" "cv::Matx< int,6,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< int,6,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_MulOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Matx_int_6_1" "', argument " "3"" of type '" "cv::Matx_MulOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_int_6_1" "', argument " "3"" of type '" "cv::Matx_MulOp""'");
} else {
cv::Matx_MulOp * temp = reinterpret_cast< cv::Matx_MulOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Matx< int,6,1 > *)new cv::Matx< int,6,1 >((cv::Matx< int,6,1 > const &)*arg1,(cv::Matx< int,6,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_int_6_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_int_6_1__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< int,6,1 > *arg1 = 0 ;
cv::Matx< int,6,1 > *arg2 = 0 ;
cv::Matx_DivOp 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 ;
cv::Matx< int,6,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Matx_int_6_1",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_int_6_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_int_6_1" "', argument " "1"" of type '" "cv::Matx< int,6,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_int_6_1" "', argument " "1"" of type '" "cv::Matx< int,6,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< int,6,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_int_6_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Matx_int_6_1" "', argument " "2"" of type '" "cv::Matx< int,6,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_int_6_1" "', argument " "2"" of type '" "cv::Matx< int,6,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< int,6,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_DivOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Matx_int_6_1" "', argument " "3"" of type '" "cv::Matx_DivOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_int_6_1" "', argument " "3"" of type '" "cv::Matx_DivOp""'");
} else {
cv::Matx_DivOp * temp = reinterpret_cast< cv::Matx_DivOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Matx< int,6,1 > *)new cv::Matx< int,6,1 >((cv::Matx< int,6,1 > const &)*arg1,(cv::Matx< int,6,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_int_6_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_int_6_1__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< int,1,6 > *arg1 = 0 ;
cv::Matx_TOp arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
cv::Matx< int,6,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:new__Matx_int_6_1",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_int_1_6_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_int_6_1" "', argument " "1"" of type '" "cv::Matx< int,1,6 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_int_6_1" "', argument " "1"" of type '" "cv::Matx< int,1,6 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< int,1,6 > * >(argp1);
{
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__Matx_TOp, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Matx_int_6_1" "', argument " "2"" of type '" "cv::Matx_TOp""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_int_6_1" "', argument " "2"" of type '" "cv::Matx_TOp""'");
} else {
cv::Matx_TOp * temp = reinterpret_cast< cv::Matx_TOp * >(argp2);
arg2 = *temp;
if (SWIG_IsNewObj(res2)) delete temp;
}
}
result = (cv::Matx< int,6,1 > *)new cv::Matx< int,6,1 >((cv::Matx< int,1,6 > const &)*arg1,arg2);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_int_6_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_int_6_1_val_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< int,6,1 > *arg1 = (cv::Matx< int,6,1 > *) 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:_Matx_int_6_1_val_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_int_6_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_int_6_1_val_set" "', argument " "1"" of type '" "cv::Matx< int,6,1 > *""'");
}
arg1 = reinterpret_cast< cv::Matx< int,6,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_int, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_int_6_1_val_set" "', argument " "2"" of type '" "int [6*1]""'");
}
arg2 = reinterpret_cast< int * >(argp2);
{
if (arg2) {
size_t ii = 0;
for (; ii < (size_t)6*1; ++ii) *(int *)&arg1->val[ii] = *((int *)arg2 + ii);
} else {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""val""' of type '""int [6*1]""'");
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_int_6_1_val_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< int,6,1 > *arg1 = (cv::Matx< int,6,1 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:_Matx_int_6_1_val_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_int_6_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_int_6_1_val_get" "', argument " "1"" of type '" "cv::Matx< int,6,1 > *""'");
}
arg1 = reinterpret_cast< cv::Matx< int,6,1 > * >(argp1);
result = (int *)(int *) ((arg1)->val);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_int_6_1__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< cv::Matx< int,6,1 >::value_type,std::allocator< cv::Matx< int,6,1 >::value_type > > arg1 ;
PyObject * obj0 = 0 ;
cv::Matx< int,6,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__Matx_int_6_1",&obj0)) SWIG_fail;
{
std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
int res = swig::asptr(obj0, &ptr);
if (!SWIG_IsOK(res) || !ptr) {
SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new__Matx_int_6_1" "', argument " "1"" of type '" "std::vector< cv::Matx< int,6,1 >::value_type,std::allocator< cv::Matx< int,6,1 >::value_type > >""'");
}
arg1 = *ptr;
if (SWIG_IsNewObj(res)) delete ptr;
}
result = (cv::Matx< int,6,1 > *)new_cv_Matx_Sl_int_Sc_6_Sc_1_Sg___SWIG_6(arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_int_6_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_int_6_1(PyObject *self, PyObject *args) {
Py_ssize_t argc;
PyObject *argv[4] = {
0
};
Py_ssize_t ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = args ? PyObject_Length(args) : 0;
for (ii = 0; (ii < 3) && (ii < argc); 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_int, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_int_6_1__SWIG_0(self, args);
}
}
if (argc == 1) {
int _v;
int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_int_6_1__SWIG_6(self, args);
}
}
if (argc == 2) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_int_1_6_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__Matx_TOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_int_6_1__SWIG_5(self, args);
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_int_6_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_int_6_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_MulOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_int_6_1__SWIG_3(self, args);
}
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_int_6_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_int_6_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_DivOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_int_6_1__SWIG_4(self, args);
}
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_int_6_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_int_6_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_AddOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_int_6_1__SWIG_1(self, args);
}
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_int_6_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_int_6_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_SubOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_int_6_1__SWIG_2(self, args);
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new__Matx_int_6_1'.\n"
" Possible C/C++ prototypes are:\n"
" cv::Matx< int,6,1 >::Matx(int const *)\n"
" cv::Matx< int,6,1 >::Matx(cv::Matx< int,6,1 > const &,cv::Matx< int,6,1 > const &,cv::Matx_AddOp)\n"
" cv::Matx< int,6,1 >::Matx(cv::Matx< int,6,1 > const &,cv::Matx< int,6,1 > const &,cv::Matx_SubOp)\n"
" cv::Matx< int,6,1 >::Matx(cv::Matx< int,6,1 > const &,cv::Matx< int,6,1 > const &,cv::Matx_MulOp)\n"
" cv::Matx< int,6,1 >::Matx(cv::Matx< int,6,1 > const &,cv::Matx< int,6,1 > const &,cv::Matx_DivOp)\n"
" cv::Matx< int,6,1 >::Matx(cv::Matx< int,1,6 > const &,cv::Matx_TOp)\n"
" cv::Matx< int,6,1 >::Matx(std::vector< cv::Matx< int,6,1 >::value_type,std::allocator< cv::Matx< int,6,1 >::value_type > >)\n");
return 0;
}
SWIGINTERN PyObject *_wrap__Matx_int_6_1___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< int,6,1 > *arg1 = (cv::Matx< int,6,1 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
std::string result;
if (!PyArg_ParseTuple(args,(char *)"O:_Matx_int_6_1___str__",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_int_6_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_int_6_1___str__" "', argument " "1"" of type '" "cv::Matx< int,6,1 > *""'");
}
arg1 = reinterpret_cast< cv::Matx< int,6,1 > * >(argp1);
result = cv_Matx_Sl_int_Sc_6_Sc_1_Sg____str__(arg1);
resultobj = SWIG_From_std_string(static_cast< std::string >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete__Matx_int_6_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< int,6,1 > *arg1 = (cv::Matx< int,6,1 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete__Matx_int_6_1",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_int_6_1_t, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__Matx_int_6_1" "', argument " "1"" of type '" "cv::Matx< int,6,1 > *""'");
}
arg1 = reinterpret_cast< cv::Matx< int,6,1 > * >(argp1);
delete arg1;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_Matx_int_6_1_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_cv__MatxT_int_6_1_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_new__Vec_int_6__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int *arg1 = (int *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
cv::Vec< int,6 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__Vec_int_6",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_int, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Vec_int_6" "', argument " "1"" of type '" "int const *""'");
}
arg1 = reinterpret_cast< int * >(argp1);
result = (cv::Vec< int,6 > *)new cv::Vec< int,6 >((int const *)arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__VecT_int_6_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Vec_int_6__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Vec< int,6 > *arg1 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
cv::Vec< int,6 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__Vec_int_6",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__VecT_int_6_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Vec_int_6" "', argument " "1"" of type '" "cv::Vec< int,6 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_int_6" "', argument " "1"" of type '" "cv::Vec< int,6 > const &""'");
}
arg1 = reinterpret_cast< cv::Vec< int,6 > * >(argp1);
result = (cv::Vec< int,6 > *)new cv::Vec< int,6 >((cv::Vec< int,6 > const &)*arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__VecT_int_6_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Vec_int_6_all(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int val1 ;
int ecode1 = 0 ;
PyObject * obj0 = 0 ;
SwigValueWrapper< cv::Vec< int,6 > > result;
if (!PyArg_ParseTuple(args,(char *)"O:_Vec_int_6_all",&obj0)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_Vec_int_6_all" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
result = cv::Vec< int,6 >::SWIGTEMPLATEDISAMBIGUATOR all(arg1);
resultobj = SWIG_NewPointerObj((new cv::Vec< int,6 >(static_cast< const cv::Vec< int,6 >& >(result))), SWIGTYPE_p_cv__VecT_int_6_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Vec_int_6_mul(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Vec< int,6 > *arg1 = (cv::Vec< int,6 > *) 0 ;
cv::Vec< int,6 > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
SwigValueWrapper< cv::Vec< int,6 > > result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Vec_int_6_mul",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__VecT_int_6_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Vec_int_6_mul" "', argument " "1"" of type '" "cv::Vec< int,6 > const *""'");
}
arg1 = reinterpret_cast< cv::Vec< int,6 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__VecT_int_6_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Vec_int_6_mul" "', argument " "2"" of type '" "cv::Vec< int,6 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Vec_int_6_mul" "', argument " "2"" of type '" "cv::Vec< int,6 > const &""'");
}
arg2 = reinterpret_cast< cv::Vec< int,6 > * >(argp2);
result = ((cv::Vec< int,6 > const *)arg1)->mul((cv::Vec< int,6 > const &)*arg2);
resultobj = SWIG_NewPointerObj((new cv::Vec< int,6 >(static_cast< const cv::Vec< int,6 >& >(result))), SWIGTYPE_p_cv__VecT_int_6_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Vec_int_6___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Vec< int,6 > *arg1 = (cv::Vec< int,6 > *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
int *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:_Vec_int_6___call__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__VecT_int_6_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Vec_int_6___call__" "', argument " "1"" of type '" "cv::Vec< int,6 > const *""'");
}
arg1 = reinterpret_cast< cv::Vec< int,6 > * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_Vec_int_6___call__" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
result = (int *) &((cv::Vec< int,6 > const *)arg1)->operator ()(arg2);
resultobj = SWIG_From_int(static_cast< int >(*result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Vec_int_6__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< int,6,1 > *arg1 = 0 ;
cv::Matx< int,6,1 > *arg2 = 0 ;
cv::Matx_AddOp 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 ;
cv::Vec< int,6 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Vec_int_6",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_int_6_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Vec_int_6" "', argument " "1"" of type '" "cv::Matx< int,6,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_int_6" "', argument " "1"" of type '" "cv::Matx< int,6,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< int,6,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_int_6_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Vec_int_6" "', argument " "2"" of type '" "cv::Matx< int,6,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_int_6" "', argument " "2"" of type '" "cv::Matx< int,6,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< int,6,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_AddOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Vec_int_6" "', argument " "3"" of type '" "cv::Matx_AddOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_int_6" "', argument " "3"" of type '" "cv::Matx_AddOp""'");
} else {
cv::Matx_AddOp * temp = reinterpret_cast< cv::Matx_AddOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Vec< int,6 > *)new cv::Vec< int,6 >((cv::Matx< int,6,1 > const &)*arg1,(cv::Matx< int,6,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__VecT_int_6_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Vec_int_6__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< int,6,1 > *arg1 = 0 ;
cv::Matx< int,6,1 > *arg2 = 0 ;
cv::Matx_SubOp 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 ;
cv::Vec< int,6 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Vec_int_6",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_int_6_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Vec_int_6" "', argument " "1"" of type '" "cv::Matx< int,6,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_int_6" "', argument " "1"" of type '" "cv::Matx< int,6,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< int,6,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_int_6_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Vec_int_6" "', argument " "2"" of type '" "cv::Matx< int,6,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_int_6" "', argument " "2"" of type '" "cv::Matx< int,6,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< int,6,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_SubOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Vec_int_6" "', argument " "3"" of type '" "cv::Matx_SubOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_int_6" "', argument " "3"" of type '" "cv::Matx_SubOp""'");
} else {
cv::Matx_SubOp * temp = reinterpret_cast< cv::Matx_SubOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Vec< int,6 > *)new cv::Vec< int,6 >((cv::Matx< int,6,1 > const &)*arg1,(cv::Matx< int,6,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__VecT_int_6_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Vec_int_6__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< cv::Vec< int,6 >::value_type,std::allocator< cv::Vec< int,6 >::value_type > > arg1 ;
PyObject * obj0 = 0 ;
cv::Vec< int,6 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__Vec_int_6",&obj0)) SWIG_fail;
{
std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
int res = swig::asptr(obj0, &ptr);
if (!SWIG_IsOK(res) || !ptr) {
SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new__Vec_int_6" "', argument " "1"" of type '" "std::vector< cv::Vec< int,6 >::value_type,std::allocator< cv::Vec< int,6 >::value_type > >""'");
}
arg1 = *ptr;
if (SWIG_IsNewObj(res)) delete ptr;
}
result = (cv::Vec< int,6 > *)new_cv_Vec_Sl_int_Sc_6_Sg___SWIG_4(arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__VecT_int_6_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Vec_int_6(PyObject *self, PyObject *args) {
Py_ssize_t argc;
PyObject *argv[4] = {
0
};
Py_ssize_t ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = args ? PyObject_Length(args) : 0;
for (ii = 0; (ii < 3) && (ii < argc); 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_int, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Vec_int_6__SWIG_0(self, args);
}
}
if (argc == 1) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__VecT_int_6_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Vec_int_6__SWIG_1(self, args);
}
}
if (argc == 1) {
int _v;
int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Vec_int_6__SWIG_4(self, args);
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_int_6_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_int_6_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_SubOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Vec_int_6__SWIG_3(self, args);
}
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_int_6_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_int_6_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_AddOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Vec_int_6__SWIG_2(self, args);
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new__Vec_int_6'.\n"
" Possible C/C++ prototypes are:\n"
" cv::Vec< int,6 >::Vec(int const *)\n"
" cv::Vec< int,6 >::Vec(cv::Vec< int,6 > const &)\n"
" cv::Vec< int,6 >::Vec(cv::Matx< int,6,1 > const &,cv::Matx< int,6,1 > const &,cv::Matx_AddOp)\n"
" cv::Vec< int,6 >::Vec(cv::Matx< int,6,1 > const &,cv::Matx< int,6,1 > const &,cv::Matx_SubOp)\n"
" cv::Vec< int,6 >::Vec(std::vector< cv::Vec< int,6 >::value_type,std::allocator< cv::Vec< int,6 >::value_type > >)\n");
return 0;
}
SWIGINTERN PyObject *_wrap__Vec_int_6___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Vec< int,6 > *arg1 = (cv::Vec< int,6 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
std::string result;
if (!PyArg_ParseTuple(args,(char *)"O:_Vec_int_6___str__",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__VecT_int_6_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Vec_int_6___str__" "', argument " "1"" of type '" "cv::Vec< int,6 > *""'");
}
arg1 = reinterpret_cast< cv::Vec< int,6 > * >(argp1);
result = cv_Vec_Sl_int_Sc_6_Sg____str__(arg1);
resultobj = SWIG_From_std_string(static_cast< std::string >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete__Vec_int_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Vec< int,6 > *arg1 = (cv::Vec< int,6 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete__Vec_int_6",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__VecT_int_6_t, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__Vec_int_6" "', argument " "1"" of type '" "cv::Vec< int,6 > *""'");
}
arg1 = reinterpret_cast< cv::Vec< int,6 > * >(argp1);
delete arg1;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_Vec_int_6_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_cv__VecT_int_6_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_new__DataType_Vec_int_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::DataType< cv::Vec< int,6 > > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new__DataType_Vec_int_6")) SWIG_fail;
result = (cv::DataType< cv::Vec< int,6 > > *)new cv::DataType< cv::Vec< int,6 > >();
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__DataTypeT_cv__VecT_int_6_t_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete__DataType_Vec_int_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::DataType< cv::Vec< int,6 > > *arg1 = (cv::DataType< cv::Vec< int,6 > > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete__DataType_Vec_int_6",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__DataTypeT_cv__VecT_int_6_t_t, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__DataType_Vec_int_6" "', argument " "1"" of type '" "cv::DataType< cv::Vec< int,6 > > *""'");
}
arg1 = reinterpret_cast< cv::DataType< cv::Vec< int,6 > > * >(argp1);
delete arg1;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_DataType_Vec_int_6_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_cv__DataTypeT_cv__VecT_int_6_t_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_new__Matx_int_8_1__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int *arg1 = (int *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
cv::Matx< int,8,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__Matx_int_8_1",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_int, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_int_8_1" "', argument " "1"" of type '" "int const *""'");
}
arg1 = reinterpret_cast< int * >(argp1);
result = (cv::Matx< int,8,1 > *)new cv::Matx< int,8,1 >((int const *)arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_int_8_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_int_8_1_all(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int val1 ;
int ecode1 = 0 ;
PyObject * obj0 = 0 ;
SwigValueWrapper< cv::Matx< int,8,1 > > result;
if (!PyArg_ParseTuple(args,(char *)"O:_Matx_int_8_1_all",&obj0)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_Matx_int_8_1_all" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
result = cv::Matx< int,8,1 >::SWIGTEMPLATEDISAMBIGUATOR all(arg1);
resultobj = SWIG_NewPointerObj((new cv::Matx< int,8,1 >(static_cast< const cv::Matx< int,8,1 >& >(result))), SWIGTYPE_p_cv__MatxT_int_8_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_int_8_1_zeros(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
SwigValueWrapper< cv::Matx< int,8,1 > > result;
if (!PyArg_ParseTuple(args,(char *)":_Matx_int_8_1_zeros")) SWIG_fail;
result = cv::Matx< int,8,1 >::SWIGTEMPLATEDISAMBIGUATOR zeros();
resultobj = SWIG_NewPointerObj((new cv::Matx< int,8,1 >(static_cast< const cv::Matx< int,8,1 >& >(result))), SWIGTYPE_p_cv__MatxT_int_8_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_int_8_1_ones(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
SwigValueWrapper< cv::Matx< int,8,1 > > result;
if (!PyArg_ParseTuple(args,(char *)":_Matx_int_8_1_ones")) SWIG_fail;
result = cv::Matx< int,8,1 >::SWIGTEMPLATEDISAMBIGUATOR ones();
resultobj = SWIG_NewPointerObj((new cv::Matx< int,8,1 >(static_cast< const cv::Matx< int,8,1 >& >(result))), SWIGTYPE_p_cv__MatxT_int_8_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_int_8_1_eye(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
SwigValueWrapper< cv::Matx< int,8,1 > > result;
if (!PyArg_ParseTuple(args,(char *)":_Matx_int_8_1_eye")) SWIG_fail;
result = cv::Matx< int,8,1 >::SWIGTEMPLATEDISAMBIGUATOR eye();
resultobj = SWIG_NewPointerObj((new cv::Matx< int,8,1 >(static_cast< const cv::Matx< int,8,1 >& >(result))), SWIGTYPE_p_cv__MatxT_int_8_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_int_8_1_randu(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 ;
SwigValueWrapper< cv::Matx< int,8,1 > > result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_int_8_1_randu",&obj0,&obj1)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_Matx_int_8_1_randu" "', 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 '" "_Matx_int_8_1_randu" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
result = cv::Matx< int,8,1 >::SWIGTEMPLATEDISAMBIGUATOR randu(arg1,arg2);
resultobj = SWIG_NewPointerObj((new cv::Matx< int,8,1 >(static_cast< const cv::Matx< int,8,1 >& >(result))), SWIGTYPE_p_cv__MatxT_int_8_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_int_8_1_randn(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 ;
SwigValueWrapper< cv::Matx< int,8,1 > > result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_int_8_1_randn",&obj0,&obj1)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_Matx_int_8_1_randn" "', 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 '" "_Matx_int_8_1_randn" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
result = cv::Matx< int,8,1 >::SWIGTEMPLATEDISAMBIGUATOR randn(arg1,arg2);
resultobj = SWIG_NewPointerObj((new cv::Matx< int,8,1 >(static_cast< const cv::Matx< int,8,1 >& >(result))), SWIGTYPE_p_cv__MatxT_int_8_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_int_8_1_dot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< int,8,1 > *arg1 = (cv::Matx< int,8,1 > *) 0 ;
cv::Matx< int,8,1 > *arg2 = 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:_Matx_int_8_1_dot",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_int_8_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_int_8_1_dot" "', argument " "1"" of type '" "cv::Matx< int,8,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< int,8,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_int_8_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_int_8_1_dot" "', argument " "2"" of type '" "cv::Matx< int,8,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Matx_int_8_1_dot" "', argument " "2"" of type '" "cv::Matx< int,8,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< int,8,1 > * >(argp2);
result = (int)((cv::Matx< int,8,1 > const *)arg1)->dot((cv::Matx< int,8,1 > const &)*arg2);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_int_8_1_ddot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< int,8,1 > *arg1 = (cv::Matx< int,8,1 > *) 0 ;
cv::Matx< int,8,1 > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
double result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_int_8_1_ddot",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_int_8_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_int_8_1_ddot" "', argument " "1"" of type '" "cv::Matx< int,8,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< int,8,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_int_8_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_int_8_1_ddot" "', argument " "2"" of type '" "cv::Matx< int,8,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Matx_int_8_1_ddot" "', argument " "2"" of type '" "cv::Matx< int,8,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< int,8,1 > * >(argp2);
result = (double)((cv::Matx< int,8,1 > const *)arg1)->ddot((cv::Matx< int,8,1 > const &)*arg2);
resultobj = SWIG_From_double(static_cast< double >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_int_8_1_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< int,8,1 > *arg1 = (cv::Matx< int,8,1 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
SwigValueWrapper< cv::Matx< int,1,8 > > result;
if (!PyArg_ParseTuple(args,(char *)"O:_Matx_int_8_1_t",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_int_8_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_int_8_1_t" "', argument " "1"" of type '" "cv::Matx< int,8,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< int,8,1 > * >(argp1);
result = ((cv::Matx< int,8,1 > const *)arg1)->t();
resultobj = SWIG_NewPointerObj((new cv::Matx< int,1,8 >(static_cast< const cv::Matx< int,1,8 >& >(result))), SWIGTYPE_p_cv__MatxT_int_1_8_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_int_8_1_mul(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< int,8,1 > *arg1 = (cv::Matx< int,8,1 > *) 0 ;
cv::Matx< int,8,1 > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
SwigValueWrapper< cv::Matx< int,8,1 > > result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_int_8_1_mul",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_int_8_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_int_8_1_mul" "', argument " "1"" of type '" "cv::Matx< int,8,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< int,8,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_int_8_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_int_8_1_mul" "', argument " "2"" of type '" "cv::Matx< int,8,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Matx_int_8_1_mul" "', argument " "2"" of type '" "cv::Matx< int,8,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< int,8,1 > * >(argp2);
result = ((cv::Matx< int,8,1 > const *)arg1)->mul((cv::Matx< int,8,1 > const &)*arg2);
resultobj = SWIG_NewPointerObj((new cv::Matx< int,8,1 >(static_cast< const cv::Matx< int,8,1 >& >(result))), SWIGTYPE_p_cv__MatxT_int_8_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_int_8_1_div(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< int,8,1 > *arg1 = (cv::Matx< int,8,1 > *) 0 ;
cv::Matx< int,8,1 > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
SwigValueWrapper< cv::Matx< int,8,1 > > result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_int_8_1_div",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_int_8_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_int_8_1_div" "', argument " "1"" of type '" "cv::Matx< int,8,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< int,8,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_int_8_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_int_8_1_div" "', argument " "2"" of type '" "cv::Matx< int,8,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Matx_int_8_1_div" "', argument " "2"" of type '" "cv::Matx< int,8,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< int,8,1 > * >(argp2);
result = ((cv::Matx< int,8,1 > const *)arg1)->div((cv::Matx< int,8,1 > const &)*arg2);
resultobj = SWIG_NewPointerObj((new cv::Matx< int,8,1 >(static_cast< const cv::Matx< int,8,1 >& >(result))), SWIGTYPE_p_cv__MatxT_int_8_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_int_8_1___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< int,8,1 > *arg1 = (cv::Matx< int,8,1 > *) 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 ;
int *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:_Matx_int_8_1___call__",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_int_8_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_int_8_1___call__" "', argument " "1"" of type '" "cv::Matx< int,8,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< int,8,1 > * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_Matx_int_8_1___call__" "', 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 '" "_Matx_int_8_1___call__" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
result = (int *) &((cv::Matx< int,8,1 > const *)arg1)->operator ()(arg2,arg3);
resultobj = SWIG_From_int(static_cast< int >(*result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_int_8_1__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< int,8,1 > *arg1 = 0 ;
cv::Matx< int,8,1 > *arg2 = 0 ;
cv::Matx_AddOp 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 ;
cv::Matx< int,8,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Matx_int_8_1",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_int_8_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_int_8_1" "', argument " "1"" of type '" "cv::Matx< int,8,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_int_8_1" "', argument " "1"" of type '" "cv::Matx< int,8,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< int,8,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_int_8_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Matx_int_8_1" "', argument " "2"" of type '" "cv::Matx< int,8,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_int_8_1" "', argument " "2"" of type '" "cv::Matx< int,8,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< int,8,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_AddOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Matx_int_8_1" "', argument " "3"" of type '" "cv::Matx_AddOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_int_8_1" "', argument " "3"" of type '" "cv::Matx_AddOp""'");
} else {
cv::Matx_AddOp * temp = reinterpret_cast< cv::Matx_AddOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Matx< int,8,1 > *)new cv::Matx< int,8,1 >((cv::Matx< int,8,1 > const &)*arg1,(cv::Matx< int,8,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_int_8_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_int_8_1__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< int,8,1 > *arg1 = 0 ;
cv::Matx< int,8,1 > *arg2 = 0 ;
cv::Matx_SubOp 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 ;
cv::Matx< int,8,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Matx_int_8_1",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_int_8_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_int_8_1" "', argument " "1"" of type '" "cv::Matx< int,8,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_int_8_1" "', argument " "1"" of type '" "cv::Matx< int,8,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< int,8,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_int_8_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Matx_int_8_1" "', argument " "2"" of type '" "cv::Matx< int,8,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_int_8_1" "', argument " "2"" of type '" "cv::Matx< int,8,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< int,8,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_SubOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Matx_int_8_1" "', argument " "3"" of type '" "cv::Matx_SubOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_int_8_1" "', argument " "3"" of type '" "cv::Matx_SubOp""'");
} else {
cv::Matx_SubOp * temp = reinterpret_cast< cv::Matx_SubOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Matx< int,8,1 > *)new cv::Matx< int,8,1 >((cv::Matx< int,8,1 > const &)*arg1,(cv::Matx< int,8,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_int_8_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_int_8_1__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< int,8,1 > *arg1 = 0 ;
cv::Matx< int,8,1 > *arg2 = 0 ;
cv::Matx_MulOp 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 ;
cv::Matx< int,8,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Matx_int_8_1",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_int_8_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_int_8_1" "', argument " "1"" of type '" "cv::Matx< int,8,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_int_8_1" "', argument " "1"" of type '" "cv::Matx< int,8,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< int,8,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_int_8_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Matx_int_8_1" "', argument " "2"" of type '" "cv::Matx< int,8,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_int_8_1" "', argument " "2"" of type '" "cv::Matx< int,8,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< int,8,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_MulOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Matx_int_8_1" "', argument " "3"" of type '" "cv::Matx_MulOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_int_8_1" "', argument " "3"" of type '" "cv::Matx_MulOp""'");
} else {
cv::Matx_MulOp * temp = reinterpret_cast< cv::Matx_MulOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Matx< int,8,1 > *)new cv::Matx< int,8,1 >((cv::Matx< int,8,1 > const &)*arg1,(cv::Matx< int,8,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_int_8_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_int_8_1__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< int,8,1 > *arg1 = 0 ;
cv::Matx< int,8,1 > *arg2 = 0 ;
cv::Matx_DivOp 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 ;
cv::Matx< int,8,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Matx_int_8_1",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_int_8_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_int_8_1" "', argument " "1"" of type '" "cv::Matx< int,8,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_int_8_1" "', argument " "1"" of type '" "cv::Matx< int,8,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< int,8,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_int_8_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Matx_int_8_1" "', argument " "2"" of type '" "cv::Matx< int,8,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_int_8_1" "', argument " "2"" of type '" "cv::Matx< int,8,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< int,8,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_DivOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Matx_int_8_1" "', argument " "3"" of type '" "cv::Matx_DivOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_int_8_1" "', argument " "3"" of type '" "cv::Matx_DivOp""'");
} else {
cv::Matx_DivOp * temp = reinterpret_cast< cv::Matx_DivOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Matx< int,8,1 > *)new cv::Matx< int,8,1 >((cv::Matx< int,8,1 > const &)*arg1,(cv::Matx< int,8,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_int_8_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_int_8_1__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< int,1,8 > *arg1 = 0 ;
cv::Matx_TOp arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
cv::Matx< int,8,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:new__Matx_int_8_1",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_int_1_8_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_int_8_1" "', argument " "1"" of type '" "cv::Matx< int,1,8 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_int_8_1" "', argument " "1"" of type '" "cv::Matx< int,1,8 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< int,1,8 > * >(argp1);
{
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__Matx_TOp, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Matx_int_8_1" "', argument " "2"" of type '" "cv::Matx_TOp""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_int_8_1" "', argument " "2"" of type '" "cv::Matx_TOp""'");
} else {
cv::Matx_TOp * temp = reinterpret_cast< cv::Matx_TOp * >(argp2);
arg2 = *temp;
if (SWIG_IsNewObj(res2)) delete temp;
}
}
result = (cv::Matx< int,8,1 > *)new cv::Matx< int,8,1 >((cv::Matx< int,1,8 > const &)*arg1,arg2);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_int_8_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_int_8_1_val_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< int,8,1 > *arg1 = (cv::Matx< int,8,1 > *) 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:_Matx_int_8_1_val_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_int_8_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_int_8_1_val_set" "', argument " "1"" of type '" "cv::Matx< int,8,1 > *""'");
}
arg1 = reinterpret_cast< cv::Matx< int,8,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_int, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_int_8_1_val_set" "', argument " "2"" of type '" "int [8*1]""'");
}
arg2 = reinterpret_cast< int * >(argp2);
{
if (arg2) {
size_t ii = 0;
for (; ii < (size_t)8*1; ++ii) *(int *)&arg1->val[ii] = *((int *)arg2 + ii);
} else {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""val""' of type '""int [8*1]""'");
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_int_8_1_val_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< int,8,1 > *arg1 = (cv::Matx< int,8,1 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:_Matx_int_8_1_val_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_int_8_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_int_8_1_val_get" "', argument " "1"" of type '" "cv::Matx< int,8,1 > *""'");
}
arg1 = reinterpret_cast< cv::Matx< int,8,1 > * >(argp1);
result = (int *)(int *) ((arg1)->val);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_int_8_1__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< cv::Matx< int,8,1 >::value_type,std::allocator< cv::Matx< int,8,1 >::value_type > > arg1 ;
PyObject * obj0 = 0 ;
cv::Matx< int,8,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__Matx_int_8_1",&obj0)) SWIG_fail;
{
std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
int res = swig::asptr(obj0, &ptr);
if (!SWIG_IsOK(res) || !ptr) {
SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new__Matx_int_8_1" "', argument " "1"" of type '" "std::vector< cv::Matx< int,8,1 >::value_type,std::allocator< cv::Matx< int,8,1 >::value_type > >""'");
}
arg1 = *ptr;
if (SWIG_IsNewObj(res)) delete ptr;
}
result = (cv::Matx< int,8,1 > *)new_cv_Matx_Sl_int_Sc_8_Sc_1_Sg___SWIG_6(arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_int_8_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_int_8_1(PyObject *self, PyObject *args) {
Py_ssize_t argc;
PyObject *argv[4] = {
0
};
Py_ssize_t ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = args ? PyObject_Length(args) : 0;
for (ii = 0; (ii < 3) && (ii < argc); 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_int, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_int_8_1__SWIG_0(self, args);
}
}
if (argc == 1) {
int _v;
int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_int_8_1__SWIG_6(self, args);
}
}
if (argc == 2) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_int_1_8_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__Matx_TOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_int_8_1__SWIG_5(self, args);
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_int_8_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_int_8_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_MulOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_int_8_1__SWIG_3(self, args);
}
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_int_8_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_int_8_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_DivOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_int_8_1__SWIG_4(self, args);
}
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_int_8_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_int_8_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_AddOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_int_8_1__SWIG_1(self, args);
}
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_int_8_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_int_8_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_SubOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_int_8_1__SWIG_2(self, args);
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new__Matx_int_8_1'.\n"
" Possible C/C++ prototypes are:\n"
" cv::Matx< int,8,1 >::Matx(int const *)\n"
" cv::Matx< int,8,1 >::Matx(cv::Matx< int,8,1 > const &,cv::Matx< int,8,1 > const &,cv::Matx_AddOp)\n"
" cv::Matx< int,8,1 >::Matx(cv::Matx< int,8,1 > const &,cv::Matx< int,8,1 > const &,cv::Matx_SubOp)\n"
" cv::Matx< int,8,1 >::Matx(cv::Matx< int,8,1 > const &,cv::Matx< int,8,1 > const &,cv::Matx_MulOp)\n"
" cv::Matx< int,8,1 >::Matx(cv::Matx< int,8,1 > const &,cv::Matx< int,8,1 > const &,cv::Matx_DivOp)\n"
" cv::Matx< int,8,1 >::Matx(cv::Matx< int,1,8 > const &,cv::Matx_TOp)\n"
" cv::Matx< int,8,1 >::Matx(std::vector< cv::Matx< int,8,1 >::value_type,std::allocator< cv::Matx< int,8,1 >::value_type > >)\n");
return 0;
}
SWIGINTERN PyObject *_wrap__Matx_int_8_1___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< int,8,1 > *arg1 = (cv::Matx< int,8,1 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
std::string result;
if (!PyArg_ParseTuple(args,(char *)"O:_Matx_int_8_1___str__",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_int_8_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_int_8_1___str__" "', argument " "1"" of type '" "cv::Matx< int,8,1 > *""'");
}
arg1 = reinterpret_cast< cv::Matx< int,8,1 > * >(argp1);
result = cv_Matx_Sl_int_Sc_8_Sc_1_Sg____str__(arg1);
resultobj = SWIG_From_std_string(static_cast< std::string >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete__Matx_int_8_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< int,8,1 > *arg1 = (cv::Matx< int,8,1 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete__Matx_int_8_1",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_int_8_1_t, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__Matx_int_8_1" "', argument " "1"" of type '" "cv::Matx< int,8,1 > *""'");
}
arg1 = reinterpret_cast< cv::Matx< int,8,1 > * >(argp1);
delete arg1;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_Matx_int_8_1_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_cv__MatxT_int_8_1_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_new__Vec_int_8__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int *arg1 = (int *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
cv::Vec< int,8 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__Vec_int_8",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_int, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Vec_int_8" "', argument " "1"" of type '" "int const *""'");
}
arg1 = reinterpret_cast< int * >(argp1);
result = (cv::Vec< int,8 > *)new cv::Vec< int,8 >((int const *)arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__VecT_int_8_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Vec_int_8__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Vec< int,8 > *arg1 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
cv::Vec< int,8 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__Vec_int_8",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__VecT_int_8_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Vec_int_8" "', argument " "1"" of type '" "cv::Vec< int,8 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_int_8" "', argument " "1"" of type '" "cv::Vec< int,8 > const &""'");
}
arg1 = reinterpret_cast< cv::Vec< int,8 > * >(argp1);
result = (cv::Vec< int,8 > *)new cv::Vec< int,8 >((cv::Vec< int,8 > const &)*arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__VecT_int_8_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Vec_int_8_all(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int val1 ;
int ecode1 = 0 ;
PyObject * obj0 = 0 ;
SwigValueWrapper< cv::Vec< int,8 > > result;
if (!PyArg_ParseTuple(args,(char *)"O:_Vec_int_8_all",&obj0)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_Vec_int_8_all" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
result = cv::Vec< int,8 >::SWIGTEMPLATEDISAMBIGUATOR all(arg1);
resultobj = SWIG_NewPointerObj((new cv::Vec< int,8 >(static_cast< const cv::Vec< int,8 >& >(result))), SWIGTYPE_p_cv__VecT_int_8_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Vec_int_8_mul(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Vec< int,8 > *arg1 = (cv::Vec< int,8 > *) 0 ;
cv::Vec< int,8 > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
SwigValueWrapper< cv::Vec< int,8 > > result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Vec_int_8_mul",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__VecT_int_8_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Vec_int_8_mul" "', argument " "1"" of type '" "cv::Vec< int,8 > const *""'");
}
arg1 = reinterpret_cast< cv::Vec< int,8 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__VecT_int_8_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Vec_int_8_mul" "', argument " "2"" of type '" "cv::Vec< int,8 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Vec_int_8_mul" "', argument " "2"" of type '" "cv::Vec< int,8 > const &""'");
}
arg2 = reinterpret_cast< cv::Vec< int,8 > * >(argp2);
result = ((cv::Vec< int,8 > const *)arg1)->mul((cv::Vec< int,8 > const &)*arg2);
resultobj = SWIG_NewPointerObj((new cv::Vec< int,8 >(static_cast< const cv::Vec< int,8 >& >(result))), SWIGTYPE_p_cv__VecT_int_8_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Vec_int_8___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Vec< int,8 > *arg1 = (cv::Vec< int,8 > *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
int *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:_Vec_int_8___call__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__VecT_int_8_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Vec_int_8___call__" "', argument " "1"" of type '" "cv::Vec< int,8 > const *""'");
}
arg1 = reinterpret_cast< cv::Vec< int,8 > * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_Vec_int_8___call__" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
result = (int *) &((cv::Vec< int,8 > const *)arg1)->operator ()(arg2);
resultobj = SWIG_From_int(static_cast< int >(*result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Vec_int_8__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< int,8,1 > *arg1 = 0 ;
cv::Matx< int,8,1 > *arg2 = 0 ;
cv::Matx_AddOp 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 ;
cv::Vec< int,8 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Vec_int_8",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_int_8_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Vec_int_8" "', argument " "1"" of type '" "cv::Matx< int,8,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_int_8" "', argument " "1"" of type '" "cv::Matx< int,8,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< int,8,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_int_8_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Vec_int_8" "', argument " "2"" of type '" "cv::Matx< int,8,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_int_8" "', argument " "2"" of type '" "cv::Matx< int,8,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< int,8,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_AddOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Vec_int_8" "', argument " "3"" of type '" "cv::Matx_AddOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_int_8" "', argument " "3"" of type '" "cv::Matx_AddOp""'");
} else {
cv::Matx_AddOp * temp = reinterpret_cast< cv::Matx_AddOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Vec< int,8 > *)new cv::Vec< int,8 >((cv::Matx< int,8,1 > const &)*arg1,(cv::Matx< int,8,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__VecT_int_8_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Vec_int_8__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< int,8,1 > *arg1 = 0 ;
cv::Matx< int,8,1 > *arg2 = 0 ;
cv::Matx_SubOp 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 ;
cv::Vec< int,8 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Vec_int_8",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_int_8_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Vec_int_8" "', argument " "1"" of type '" "cv::Matx< int,8,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_int_8" "', argument " "1"" of type '" "cv::Matx< int,8,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< int,8,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_int_8_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Vec_int_8" "', argument " "2"" of type '" "cv::Matx< int,8,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_int_8" "', argument " "2"" of type '" "cv::Matx< int,8,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< int,8,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_SubOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Vec_int_8" "', argument " "3"" of type '" "cv::Matx_SubOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_int_8" "', argument " "3"" of type '" "cv::Matx_SubOp""'");
} else {
cv::Matx_SubOp * temp = reinterpret_cast< cv::Matx_SubOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Vec< int,8 > *)new cv::Vec< int,8 >((cv::Matx< int,8,1 > const &)*arg1,(cv::Matx< int,8,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__VecT_int_8_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Vec_int_8__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< cv::Vec< int,8 >::value_type,std::allocator< cv::Vec< int,8 >::value_type > > arg1 ;
PyObject * obj0 = 0 ;
cv::Vec< int,8 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__Vec_int_8",&obj0)) SWIG_fail;
{
std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
int res = swig::asptr(obj0, &ptr);
if (!SWIG_IsOK(res) || !ptr) {
SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new__Vec_int_8" "', argument " "1"" of type '" "std::vector< cv::Vec< int,8 >::value_type,std::allocator< cv::Vec< int,8 >::value_type > >""'");
}
arg1 = *ptr;
if (SWIG_IsNewObj(res)) delete ptr;
}
result = (cv::Vec< int,8 > *)new_cv_Vec_Sl_int_Sc_8_Sg___SWIG_4(arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__VecT_int_8_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Vec_int_8(PyObject *self, PyObject *args) {
Py_ssize_t argc;
PyObject *argv[4] = {
0
};
Py_ssize_t ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = args ? PyObject_Length(args) : 0;
for (ii = 0; (ii < 3) && (ii < argc); 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_int, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Vec_int_8__SWIG_0(self, args);
}
}
if (argc == 1) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__VecT_int_8_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Vec_int_8__SWIG_1(self, args);
}
}
if (argc == 1) {
int _v;
int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Vec_int_8__SWIG_4(self, args);
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_int_8_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_int_8_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_SubOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Vec_int_8__SWIG_3(self, args);
}
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_int_8_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_int_8_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_AddOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Vec_int_8__SWIG_2(self, args);
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new__Vec_int_8'.\n"
" Possible C/C++ prototypes are:\n"
" cv::Vec< int,8 >::Vec(int const *)\n"
" cv::Vec< int,8 >::Vec(cv::Vec< int,8 > const &)\n"
" cv::Vec< int,8 >::Vec(cv::Matx< int,8,1 > const &,cv::Matx< int,8,1 > const &,cv::Matx_AddOp)\n"
" cv::Vec< int,8 >::Vec(cv::Matx< int,8,1 > const &,cv::Matx< int,8,1 > const &,cv::Matx_SubOp)\n"
" cv::Vec< int,8 >::Vec(std::vector< cv::Vec< int,8 >::value_type,std::allocator< cv::Vec< int,8 >::value_type > >)\n");
return 0;
}
SWIGINTERN PyObject *_wrap__Vec_int_8___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Vec< int,8 > *arg1 = (cv::Vec< int,8 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
std::string result;
if (!PyArg_ParseTuple(args,(char *)"O:_Vec_int_8___str__",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__VecT_int_8_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Vec_int_8___str__" "', argument " "1"" of type '" "cv::Vec< int,8 > *""'");
}
arg1 = reinterpret_cast< cv::Vec< int,8 > * >(argp1);
result = cv_Vec_Sl_int_Sc_8_Sg____str__(arg1);
resultobj = SWIG_From_std_string(static_cast< std::string >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete__Vec_int_8(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Vec< int,8 > *arg1 = (cv::Vec< int,8 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete__Vec_int_8",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__VecT_int_8_t, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__Vec_int_8" "', argument " "1"" of type '" "cv::Vec< int,8 > *""'");
}
arg1 = reinterpret_cast< cv::Vec< int,8 > * >(argp1);
delete arg1;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_Vec_int_8_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_cv__VecT_int_8_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_new__DataType_Vec_int_8(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::DataType< cv::Vec< int,8 > > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new__DataType_Vec_int_8")) SWIG_fail;
result = (cv::DataType< cv::Vec< int,8 > > *)new cv::DataType< cv::Vec< int,8 > >();
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__DataTypeT_cv__VecT_int_8_t_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete__DataType_Vec_int_8(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::DataType< cv::Vec< int,8 > > *arg1 = (cv::DataType< cv::Vec< int,8 > > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete__DataType_Vec_int_8",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__DataTypeT_cv__VecT_int_8_t_t, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__DataType_Vec_int_8" "', argument " "1"" of type '" "cv::DataType< cv::Vec< int,8 > > *""'");
}
arg1 = reinterpret_cast< cv::DataType< cv::Vec< int,8 > > * >(argp1);
delete arg1;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_DataType_Vec_int_8_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_cv__DataTypeT_cv__VecT_int_8_t_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_new__cv_numpy_sizeof_float(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::_SizeOf< float > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new__cv_numpy_sizeof_float")) SWIG_fail;
result = (cv::_SizeOf< float > *)new cv::_SizeOf< float >();
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv___SizeOfT_float_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete__cv_numpy_sizeof_float(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::_SizeOf< float > *arg1 = (cv::_SizeOf< float > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete__cv_numpy_sizeof_float",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv___SizeOfT_float_t, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__cv_numpy_sizeof_float" "', argument " "1"" of type '" "cv::_SizeOf< float > *""'");
}
arg1 = reinterpret_cast< cv::_SizeOf< float > * >(argp1);
delete arg1;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_cv_numpy_sizeof_float_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_cv___SizeOfT_float_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap__floatArray_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::SwigPyIterator *result = 0 ;
arg2 = &obj0;
if (!PyArg_ParseTuple(args,(char *)"O:_floatArray_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 '" "_floatArray_iterator" "', argument " "1"" of type '" "std::vector< float > *""'");
}
arg1 = reinterpret_cast< std::vector< float > * >(argp1);
result = (swig::SwigPyIterator *)std_vector_Sl_float_Sg__iterator(arg1,arg2);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__floatArray___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:_floatArray___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 '" "_floatArray___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__floatArray___bool__(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:_floatArray___bool__",&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 '" "_floatArray___bool__" "', argument " "1"" of type '" "std::vector< float > const *""'");
}
arg1 = reinterpret_cast< std::vector< float > * >(argp1);
result = (bool)std_vector_Sl_float_Sg____bool__((std::vector< float > const *)arg1);
resultobj = SWIG_From_bool(static_cast< bool >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__floatArray___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:_floatArray___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 '" "_floatArray___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__floatArray___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:_floatArray___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 '" "_floatArray___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 '" "_floatArray___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 '" "_floatArray___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());
}
catch(std::invalid_argument &_e) {
SWIG_exception_fail(SWIG_ValueError, (&_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__floatArray___setslice____SWIG_0(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:_floatArray___setslice__",&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 '" "_floatArray___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 '" "_floatArray___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 '" "_floatArray___setslice__" "', argument " "3"" of type '" "std::vector< float >::difference_type""'");
}
arg3 = static_cast< std::vector< float >::difference_type >(val3);
try {
std_vector_Sl_float_Sg____setslice____SWIG_0(arg1,arg2,arg3);
}
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();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__floatArray___setslice____SWIG_1(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:_floatArray___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 '" "_floatArray___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 '" "_floatArray___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 '" "_floatArray___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 '" "_floatArray___setslice__" "', argument " "4"" of type '" "std::vector< float,std::allocator< float > > const &""'");
}
if (!ptr) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_floatArray___setslice__" "', argument " "4"" of type '" "std::vector< float,std::allocator< float > > const &""'");
}
arg4 = ptr;
}
try {
std_vector_Sl_float_Sg____setslice____SWIG_1(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__floatArray___setslice__(PyObject *self, PyObject *args) {
Py_ssize_t argc;
PyObject *argv[5] = {
0
};
Py_ssize_t ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = args ? PyObject_Length(args) : 0;
for (ii = 0; (ii < 4) && (ii < argc); 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) {
{
int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap__floatArray___setslice____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) {
{
int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
_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) {
return _wrap__floatArray___setslice____SWIG_1(self, args);
}
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function '_floatArray___setslice__'.\n"
" Possible C/C++ prototypes are:\n"
" std::vector< float >::__setslice__(std::vector< float >::difference_type,std::vector< float >::difference_type)\n"
" std::vector< float >::__setslice__(std::vector< float >::difference_type,std::vector< float >::difference_type,std::vector< float,std::allocator< float > > const &)\n");
return 0;
}
SWIGINTERN PyObject *_wrap__floatArray___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:_floatArray___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 '" "_floatArray___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 '" "_floatArray___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 '" "_floatArray___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());
}
catch(std::invalid_argument &_e) {
SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__floatArray___delitem____SWIG_0(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:_floatArray___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 '" "_floatArray___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 '" "_floatArray___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____SWIG_0(arg1,arg2);
}
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();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__floatArray___getitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< float > *arg1 = (std::vector< float > *) 0 ;
PySliceObject *arg2 = (PySliceObject *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
std::vector< float,std::allocator< float > > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:_floatArray___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 '" "_floatArray___getitem__" "', argument " "1"" of type '" "std::vector< float > *""'");
}
arg1 = reinterpret_cast< std::vector< float > * >(argp1);
{
if (!PySlice_Check(obj1)) {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "_floatArray___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
arg2 = (PySliceObject *) obj1;
}
try {
result = (std::vector< float,std::allocator< float > > *)std_vector_Sl_float_Sg____getitem____SWIG_0(arg1,arg2);
}
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_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__floatArray___setitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< float > *arg1 = (std::vector< float > *) 0 ;
PySliceObject *arg2 = (PySliceObject *) 0 ;
std::vector< float,std::allocator< float > > *arg3 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res3 = SWIG_OLDOBJ ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:_floatArray___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 '" "_floatArray___setitem__" "', argument " "1"" of type '" "std::vector< float > *""'");
}
arg1 = reinterpret_cast< std::vector< float > * >(argp1);
{
if (!PySlice_Check(obj1)) {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "_floatArray___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
arg2 = (PySliceObject *) obj1;
}
{
std::vector< float,std::allocator< float > > *ptr = (std::vector< float,std::allocator< float > > *)0;
res3 = swig::asptr(obj2, &ptr);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "_floatArray___setitem__" "', argument " "3"" of type '" "std::vector< float,std::allocator< float > > const &""'");
}
if (!ptr) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_floatArray___setitem__" "', argument " "3"" of type '" "std::vector< float,std::allocator< float > > const &""'");
}
arg3 = ptr;
}
try {
std_vector_Sl_float_Sg____setitem____SWIG_0(arg1,arg2,(std::vector< float,std::allocator< float > > const &)*arg3);
}
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(res3)) delete arg3;
return resultobj;
fail:
if (SWIG_IsNewObj(res3)) delete arg3;
return NULL;
}
SWIGINTERN PyObject *_wrap__floatArray___setitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< float > *arg1 = (std::vector< float > *) 0 ;
PySliceObject *arg2 = (PySliceObject *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:_floatArray___setitem__",&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 '" "_floatArray___setitem__" "', argument " "1"" of type '" "std::vector< float > *""'");
}
arg1 = reinterpret_cast< std::vector< float > * >(argp1);
{
if (!PySlice_Check(obj1)) {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "_floatArray___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
arg2 = (PySliceObject *) obj1;
}
try {
std_vector_Sl_float_Sg____setitem____SWIG_1(arg1,arg2);
}
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();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__floatArray___delitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< float > *arg1 = (std::vector< float > *) 0 ;
PySliceObject *arg2 = (PySliceObject *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:_floatArray___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 '" "_floatArray___delitem__" "', argument " "1"" of type '" "std::vector< float > *""'");
}
arg1 = reinterpret_cast< std::vector< float > * >(argp1);
{
if (!PySlice_Check(obj1)) {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "_floatArray___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
arg2 = (PySliceObject *) obj1;
}
try {
std_vector_Sl_float_Sg____delitem____SWIG_1(arg1,arg2);
}
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();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__floatArray___delitem__(PyObject *self, PyObject *args) {
Py_ssize_t argc;
PyObject *argv[3] = {
0
};
Py_ssize_t ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = args ? PyObject_Length(args) : 0;
for (ii = 0; (ii < 2) && (ii < argc); 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) {
{
_v = PySlice_Check(argv[1]);
}
if (_v) {
return _wrap__floatArray___delitem____SWIG_1(self, args);
}
}
}
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_ptrdiff_t(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap__floatArray___delitem____SWIG_0(self, args);
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function '_floatArray___delitem__'.\n"
" Possible C/C++ prototypes are:\n"
" std::vector< float >::__delitem__(std::vector< float >::difference_type)\n"
" std::vector< float >::__delitem__(PySliceObject *)\n");
return 0;
}
SWIGINTERN PyObject *_wrap__floatArray___getitem____SWIG_1(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:_floatArray___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 '" "_floatArray___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 '" "_floatArray___getitem__" "', argument " "2"" of type '" "std::vector< float >::difference_type""'");
}
arg2 = static_cast< std::vector< float >::difference_type >(val2);
try {
result = (std::vector< float >::value_type *) &std_vector_Sl_float_Sg____getitem____SWIG_1((std::vector< float > const *)arg1,arg2);
}
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__floatArray___getitem__(PyObject *self, PyObject *args) {
Py_ssize_t argc;
PyObject *argv[3] = {
0
};
Py_ssize_t ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = args ? PyObject_Length(args) : 0;
for (ii = 0; (ii < 2) && (ii < argc); 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) {
{
_v = PySlice_Check(argv[1]);
}
if (_v) {
return _wrap__floatArray___getitem____SWIG_0(self, args);
}
}
}
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_ptrdiff_t(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap__floatArray___getitem____SWIG_1(self, args);
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function '_floatArray___getitem__'.\n"
" Possible C/C++ prototypes are:\n"
" std::vector< float >::__getitem__(PySliceObject *)\n"
" std::vector< float >::__getitem__(std::vector< float >::difference_type) const\n");
return 0;
}
SWIGINTERN PyObject *_wrap__floatArray___setitem____SWIG_2(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:_floatArray___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 '" "_floatArray___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 '" "_floatArray___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 '" "_floatArray___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____SWIG_2(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__floatArray___setitem__(PyObject *self, PyObject *args) {
Py_ssize_t argc;
PyObject *argv[4] = {
0
};
Py_ssize_t ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = args ? PyObject_Length(args) : 0;
for (ii = 0; (ii < 3) && (ii < argc); 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) {
{
_v = PySlice_Check(argv[1]);
}
if (_v) {
return _wrap__floatArray___setitem____SWIG_1(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) {
{
_v = PySlice_Check(argv[1]);
}
if (_v) {
int res = swig::asptr(argv[2], (std::vector< float,std::allocator< float > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
return _wrap__floatArray___setitem____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_ptrdiff_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__floatArray___setitem____SWIG_2(self, args);
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function '_floatArray___setitem__'.\n"
" Possible C/C++ prototypes are:\n"
" std::vector< float >::__setitem__(PySliceObject *,std::vector< float,std::allocator< float > > const &)\n"
" std::vector< float >::__setitem__(PySliceObject *)\n"
" std::vector< float >::__setitem__(std::vector< float >::difference_type,std::vector< float >::value_type const &)\n");
return 0;
}
SWIGINTERN PyObject *_wrap__floatArray_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:_floatArray_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 '" "_floatArray_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__floatArray_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:_floatArray_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 '" "_floatArray_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 '" "_floatArray_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__floatArray__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< float > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new__floatArray")) 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__floatArray__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__floatArray",&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__floatArray" "', argument " "1"" of type '" "std::vector< float > const &""'");
}
if (!ptr) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__floatArray" "', 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__floatArray_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:_floatArray_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 '" "_floatArray_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__floatArray_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:_floatArray_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 '" "_floatArray_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__floatArray_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:_floatArray_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 '" "_floatArray_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 '" "_floatArray_swap" "', argument " "2"" of type '" "std::vector< float > &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_floatArray_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__floatArray_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 >::iterator result;
if (!PyArg_ParseTuple(args,(char *)"O:_floatArray_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 '" "_floatArray_begin" "', argument " "1"" of type '" "std::vector< float > *""'");
}
arg1 = reinterpret_cast< std::vector< float > * >(argp1);
result = (arg1)->begin();
resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< float >::iterator & >(result)),
swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__floatArray_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 >::iterator result;
if (!PyArg_ParseTuple(args,(char *)"O:_floatArray_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 '" "_floatArray_end" "', argument " "1"" of type '" "std::vector< float > *""'");
}
arg1 = reinterpret_cast< std::vector< float > * >(argp1);
result = (arg1)->end();
resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< float >::iterator & >(result)),
swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__floatArray_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 >::reverse_iterator result;
if (!PyArg_ParseTuple(args,(char *)"O:_floatArray_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 '" "_floatArray_rbegin" "', argument " "1"" of type '" "std::vector< float > *""'");
}
arg1 = reinterpret_cast< std::vector< float > * >(argp1);
result = (arg1)->rbegin();
resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< float >::reverse_iterator & >(result)),
swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__floatArray_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 >::reverse_iterator result;
if (!PyArg_ParseTuple(args,(char *)"O:_floatArray_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 '" "_floatArray_rend" "', argument " "1"" of type '" "std::vector< float > *""'");
}
arg1 = reinterpret_cast< std::vector< float > * >(argp1);
result = (arg1)->rend();
resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< float >::reverse_iterator & >(result)),
swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__floatArray_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:_floatArray_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 '" "_floatArray_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__floatArray_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:_floatArray_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 '" "_floatArray_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__allocatorT_float_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__floatArray__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__floatArray",&obj0)) SWIG_fail;
ecode1 = SWIG_AsVal_size_t(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new__floatArray" "', 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__floatArray_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:_floatArray_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 '" "_floatArray_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__floatArray_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:_floatArray_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 '" "_floatArray_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 '" "_floatArray_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__floatArray_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::SwigPyIterator *iter2 = 0 ;
int res2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
std::vector< float >::iterator result;
if (!PyArg_ParseTuple(args,(char *)"OO:_floatArray_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 '" "_floatArray_erase" "', argument " "1"" of type '" "std::vector< float > *""'");
}
arg1 = reinterpret_cast< std::vector< float > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
if (!SWIG_IsOK(res2) || !iter2) {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "_floatArray_erase" "', argument " "2"" of type '" "std::vector< float >::iterator""'");
} else {
swig::SwigPyIterator_T<std::vector< float >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< float >::iterator > *>(iter2);
if (iter_t) {
arg2 = iter_t->get_current();
} else {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "_floatArray_erase" "', argument " "2"" of type '" "std::vector< float >::iterator""'");
}
}
result = std_vector_Sl_float_Sg__erase__SWIG_0(arg1,arg2);
resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< float >::iterator & >(result)),
swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__floatArray_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::SwigPyIterator *iter2 = 0 ;
int res2 ;
swig::SwigPyIterator *iter3 = 0 ;
int res3 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
std::vector< float >::iterator result;
if (!PyArg_ParseTuple(args,(char *)"OOO:_floatArray_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 '" "_floatArray_erase" "', argument " "1"" of type '" "std::vector< float > *""'");
}
arg1 = reinterpret_cast< std::vector< float > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
if (!SWIG_IsOK(res2) || !iter2) {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "_floatArray_erase" "', argument " "2"" of type '" "std::vector< float >::iterator""'");
} else {
swig::SwigPyIterator_T<std::vector< float >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< float >::iterator > *>(iter2);
if (iter_t) {
arg2 = iter_t->get_current();
} else {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "_floatArray_erase" "', argument " "2"" of type '" "std::vector< float >::iterator""'");
}
}
res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
if (!SWIG_IsOK(res3) || !iter3) {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "_floatArray_erase" "', argument " "3"" of type '" "std::vector< float >::iterator""'");
} else {
swig::SwigPyIterator_T<std::vector< float >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< float >::iterator > *>(iter3);
if (iter_t) {
arg3 = iter_t->get_current();
} else {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "_floatArray_erase" "', argument " "3"" of type '" "std::vector< float >::iterator""'");
}
}
result = std_vector_Sl_float_Sg__erase__SWIG_1(arg1,arg2,arg3);
resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< float >::iterator & >(result)),
swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__floatArray_erase(PyObject *self, PyObject *args) {
Py_ssize_t argc;
PyObject *argv[4] = {
0
};
Py_ssize_t ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = args ? PyObject_Length(args) : 0;
for (ii = 0; (ii < 3) && (ii < argc); 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::SwigPyIterator *iter = 0;
int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
_v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< float >::iterator > *>(iter) != 0));
if (_v) {
return _wrap__floatArray_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::SwigPyIterator *iter = 0;
int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
_v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< float >::iterator > *>(iter) != 0));
if (_v) {
swig::SwigPyIterator *iter = 0;
int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
_v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< float >::iterator > *>(iter) != 0));
if (_v) {
return _wrap__floatArray_erase__SWIG_1(self, args);
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function '_floatArray_erase'.\n"
" Possible C/C++ prototypes are:\n"
" std::vector< float >::erase(std::vector< float >::iterator)\n"
" std::vector< float >::erase(std::vector< float >::iterator,std::vector< float >::iterator)\n");
return 0;
}
SWIGINTERN PyObject *_wrap_new__floatArray__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__floatArray",&obj0,&obj1)) SWIG_fail;
ecode1 = SWIG_AsVal_size_t(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new__floatArray" "', 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__floatArray" "', 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__floatArray(PyObject *self, PyObject *args) {
Py_ssize_t argc;
PyObject *argv[3] = {
0
};
Py_ssize_t ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = args ? PyObject_Length(args) : 0;
for (ii = 0; (ii < 2) && (ii < argc); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 0) {
return _wrap_new__floatArray__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__floatArray__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__floatArray__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__floatArray__SWIG_3(self, args);
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new__floatArray'.\n"
" Possible C/C++ prototypes are:\n"
" std::vector< float >::vector()\n"
" std::vector< float >::vector(std::vector< float > const &)\n"
" std::vector< float >::vector(std::vector< float >::size_type)\n"
" std::vector< float >::vector(std::vector< float >::size_type,std::vector< float >::value_type const &)\n");
return 0;
}
SWIGINTERN PyObject *_wrap__floatArray_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:_floatArray_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 '" "_floatArray_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 '" "_floatArray_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__floatArray_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:_floatArray_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 '" "_floatArray_front" "', argument " "1"" of type '" "std::vector< float > const *""'");
}
arg1 = reinterpret_cast< std::vector< float > * >(argp1);
result = (std::vector< float >::value_type *) &((std::vector< float > const *)arg1)->front();
resultobj = SWIG_From_float(static_cast< float >(*result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__floatArray_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:_floatArray_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 '" "_floatArray_back" "', argument " "1"" of type '" "std::vector< float > const *""'");
}
arg1 = reinterpret_cast< std::vector< float > * >(argp1);
result = (std::vector< float >::value_type *) &((std::vector< float > const *)arg1)->back();
resultobj = SWIG_From_float(static_cast< float >(*result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__floatArray_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:_floatArray_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 '" "_floatArray_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 '" "_floatArray_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 '" "_floatArray_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__floatArray_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:_floatArray_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 '" "_floatArray_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 '" "_floatArray_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 '" "_floatArray_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__floatArray_resize(PyObject *self, PyObject *args) {
Py_ssize_t argc;
PyObject *argv[4] = {
0
};
Py_ssize_t ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = args ? PyObject_Length(args) : 0;
for (ii = 0; (ii < 3) && (ii < argc); 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__floatArray_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__floatArray_resize__SWIG_1(self, args);
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function '_floatArray_resize'.\n"
" Possible C/C++ prototypes are:\n"
" std::vector< float >::resize(std::vector< float >::size_type)\n"
" std::vector< float >::resize(std::vector< float >::size_type,std::vector< float >::value_type const &)\n");
return 0;
}
SWIGINTERN PyObject *_wrap__floatArray_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::SwigPyIterator *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:_floatArray_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 '" "_floatArray_insert" "', argument " "1"" of type '" "std::vector< float > *""'");
}
arg1 = reinterpret_cast< std::vector< float > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
if (!SWIG_IsOK(res2) || !iter2) {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "_floatArray_insert" "', argument " "2"" of type '" "std::vector< float >::iterator""'");
} else {
swig::SwigPyIterator_T<std::vector< float >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< float >::iterator > *>(iter2);
if (iter_t) {
arg2 = iter_t->get_current();
} else {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "_floatArray_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 '" "_floatArray_insert" "', argument " "3"" of type '" "std::vector< float >::value_type""'");
}
temp3 = static_cast< std::vector< float >::value_type >(val3);
arg3 = &temp3;
result = std_vector_Sl_float_Sg__insert__SWIG_0(arg1,arg2,(float const &)*arg3);
resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< float >::iterator & >(result)),
swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__floatArray_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::SwigPyIterator *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:_floatArray_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 '" "_floatArray_insert" "', argument " "1"" of type '" "std::vector< float > *""'");
}
arg1 = reinterpret_cast< std::vector< float > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
if (!SWIG_IsOK(res2) || !iter2) {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "_floatArray_insert" "', argument " "2"" of type '" "std::vector< float >::iterator""'");
} else {
swig::SwigPyIterator_T<std::vector< float >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< float >::iterator > *>(iter2);
if (iter_t) {
arg2 = iter_t->get_current();
} else {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "_floatArray_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 '" "_floatArray_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 '" "_floatArray_insert" "', argument " "4"" of type '" "std::vector< float >::value_type""'");
}
temp4 = static_cast< std::vector< float >::value_type >(val4);
arg4 = &temp4;
std_vector_Sl_float_Sg__insert__SWIG_1(arg1,arg2,arg3,(float const &)*arg4);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__floatArray_insert(PyObject *self, PyObject *args) {
Py_ssize_t argc;
PyObject *argv[5] = {
0
};
Py_ssize_t ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = args ? PyObject_Length(args) : 0;
for (ii = 0; (ii < 4) && (ii < argc); 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::SwigPyIterator *iter = 0;
int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
_v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_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__floatArray_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::SwigPyIterator *iter = 0;
int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
_v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_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__floatArray_insert__SWIG_1(self, args);
}
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function '_floatArray_insert'.\n"
" Possible C/C++ prototypes are:\n"
" std::vector< float >::insert(std::vector< float >::iterator,std::vector< float >::value_type const &)\n"
" std::vector< float >::insert(std::vector< float >::iterator,std::vector< float >::size_type,std::vector< float >::value_type const &)\n");
return 0;
}
SWIGINTERN PyObject *_wrap__floatArray_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:_floatArray_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 '" "_floatArray_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 '" "_floatArray_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__floatArray_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:_floatArray_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 '" "_floatArray_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__floatArray(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__floatArray",&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__floatArray" "', argument " "1"" of type '" "std::vector< float > *""'");
}
arg1 = reinterpret_cast< std::vector< float > * >(argp1);
delete arg1;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_floatArray_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_new__Matx_float_2_1__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
float *arg1 = (float *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
cv::Matx< float,2,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__Matx_float_2_1",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_float, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_float_2_1" "', argument " "1"" of type '" "float const *""'");
}
arg1 = reinterpret_cast< float * >(argp1);
result = (cv::Matx< float,2,1 > *)new cv::Matx< float,2,1 >((float const *)arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_float_2_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_float_2_1_all(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
float arg1 ;
float val1 ;
int ecode1 = 0 ;
PyObject * obj0 = 0 ;
SwigValueWrapper< cv::Matx< float,2,1 > > result;
if (!PyArg_ParseTuple(args,(char *)"O:_Matx_float_2_1_all",&obj0)) SWIG_fail;
ecode1 = SWIG_AsVal_float(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_Matx_float_2_1_all" "', argument " "1"" of type '" "float""'");
}
arg1 = static_cast< float >(val1);
result = cv::Matx< float,2,1 >::SWIGTEMPLATEDISAMBIGUATOR all(arg1);
resultobj = SWIG_NewPointerObj((new cv::Matx< float,2,1 >(static_cast< const cv::Matx< float,2,1 >& >(result))), SWIGTYPE_p_cv__MatxT_float_2_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_float_2_1_zeros(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
SwigValueWrapper< cv::Matx< float,2,1 > > result;
if (!PyArg_ParseTuple(args,(char *)":_Matx_float_2_1_zeros")) SWIG_fail;
result = cv::Matx< float,2,1 >::SWIGTEMPLATEDISAMBIGUATOR zeros();
resultobj = SWIG_NewPointerObj((new cv::Matx< float,2,1 >(static_cast< const cv::Matx< float,2,1 >& >(result))), SWIGTYPE_p_cv__MatxT_float_2_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_float_2_1_ones(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
SwigValueWrapper< cv::Matx< float,2,1 > > result;
if (!PyArg_ParseTuple(args,(char *)":_Matx_float_2_1_ones")) SWIG_fail;
result = cv::Matx< float,2,1 >::SWIGTEMPLATEDISAMBIGUATOR ones();
resultobj = SWIG_NewPointerObj((new cv::Matx< float,2,1 >(static_cast< const cv::Matx< float,2,1 >& >(result))), SWIGTYPE_p_cv__MatxT_float_2_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_float_2_1_eye(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
SwigValueWrapper< cv::Matx< float,2,1 > > result;
if (!PyArg_ParseTuple(args,(char *)":_Matx_float_2_1_eye")) SWIG_fail;
result = cv::Matx< float,2,1 >::SWIGTEMPLATEDISAMBIGUATOR eye();
resultobj = SWIG_NewPointerObj((new cv::Matx< float,2,1 >(static_cast< const cv::Matx< float,2,1 >& >(result))), SWIGTYPE_p_cv__MatxT_float_2_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_float_2_1_randu(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 ;
SwigValueWrapper< cv::Matx< float,2,1 > > result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_float_2_1_randu",&obj0,&obj1)) SWIG_fail;
ecode1 = SWIG_AsVal_float(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_Matx_float_2_1_randu" "', 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 '" "_Matx_float_2_1_randu" "', argument " "2"" of type '" "float""'");
}
arg2 = static_cast< float >(val2);
result = cv::Matx< float,2,1 >::SWIGTEMPLATEDISAMBIGUATOR randu(arg1,arg2);
resultobj = SWIG_NewPointerObj((new cv::Matx< float,2,1 >(static_cast< const cv::Matx< float,2,1 >& >(result))), SWIGTYPE_p_cv__MatxT_float_2_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_float_2_1_randn(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 ;
SwigValueWrapper< cv::Matx< float,2,1 > > result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_float_2_1_randn",&obj0,&obj1)) SWIG_fail;
ecode1 = SWIG_AsVal_float(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_Matx_float_2_1_randn" "', 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 '" "_Matx_float_2_1_randn" "', argument " "2"" of type '" "float""'");
}
arg2 = static_cast< float >(val2);
result = cv::Matx< float,2,1 >::SWIGTEMPLATEDISAMBIGUATOR randn(arg1,arg2);
resultobj = SWIG_NewPointerObj((new cv::Matx< float,2,1 >(static_cast< const cv::Matx< float,2,1 >& >(result))), SWIGTYPE_p_cv__MatxT_float_2_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_float_2_1_dot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< float,2,1 > *arg1 = (cv::Matx< float,2,1 > *) 0 ;
cv::Matx< float,2,1 > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
float result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_float_2_1_dot",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_float_2_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_float_2_1_dot" "', argument " "1"" of type '" "cv::Matx< float,2,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< float,2,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_float_2_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_float_2_1_dot" "', argument " "2"" of type '" "cv::Matx< float,2,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Matx_float_2_1_dot" "', argument " "2"" of type '" "cv::Matx< float,2,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< float,2,1 > * >(argp2);
result = (float)((cv::Matx< float,2,1 > const *)arg1)->dot((cv::Matx< float,2,1 > const &)*arg2);
resultobj = SWIG_From_float(static_cast< float >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_float_2_1_ddot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< float,2,1 > *arg1 = (cv::Matx< float,2,1 > *) 0 ;
cv::Matx< float,2,1 > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
double result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_float_2_1_ddot",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_float_2_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_float_2_1_ddot" "', argument " "1"" of type '" "cv::Matx< float,2,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< float,2,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_float_2_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_float_2_1_ddot" "', argument " "2"" of type '" "cv::Matx< float,2,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Matx_float_2_1_ddot" "', argument " "2"" of type '" "cv::Matx< float,2,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< float,2,1 > * >(argp2);
result = (double)((cv::Matx< float,2,1 > const *)arg1)->ddot((cv::Matx< float,2,1 > const &)*arg2);
resultobj = SWIG_From_double(static_cast< double >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_float_2_1_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< float,2,1 > *arg1 = (cv::Matx< float,2,1 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
SwigValueWrapper< cv::Matx< float,1,2 > > result;
if (!PyArg_ParseTuple(args,(char *)"O:_Matx_float_2_1_t",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_float_2_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_float_2_1_t" "', argument " "1"" of type '" "cv::Matx< float,2,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< float,2,1 > * >(argp1);
result = ((cv::Matx< float,2,1 > const *)arg1)->t();
resultobj = SWIG_NewPointerObj((new cv::Matx< float,1,2 >(static_cast< const cv::Matx< float,1,2 >& >(result))), SWIGTYPE_p_cv__MatxT_float_1_2_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_float_2_1_mul(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< float,2,1 > *arg1 = (cv::Matx< float,2,1 > *) 0 ;
cv::Matx< float,2,1 > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
SwigValueWrapper< cv::Matx< float,2,1 > > result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_float_2_1_mul",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_float_2_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_float_2_1_mul" "', argument " "1"" of type '" "cv::Matx< float,2,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< float,2,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_float_2_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_float_2_1_mul" "', argument " "2"" of type '" "cv::Matx< float,2,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Matx_float_2_1_mul" "', argument " "2"" of type '" "cv::Matx< float,2,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< float,2,1 > * >(argp2);
result = ((cv::Matx< float,2,1 > const *)arg1)->mul((cv::Matx< float,2,1 > const &)*arg2);
resultobj = SWIG_NewPointerObj((new cv::Matx< float,2,1 >(static_cast< const cv::Matx< float,2,1 >& >(result))), SWIGTYPE_p_cv__MatxT_float_2_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_float_2_1_div(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< float,2,1 > *arg1 = (cv::Matx< float,2,1 > *) 0 ;
cv::Matx< float,2,1 > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
SwigValueWrapper< cv::Matx< float,2,1 > > result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_float_2_1_div",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_float_2_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_float_2_1_div" "', argument " "1"" of type '" "cv::Matx< float,2,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< float,2,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_float_2_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_float_2_1_div" "', argument " "2"" of type '" "cv::Matx< float,2,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Matx_float_2_1_div" "', argument " "2"" of type '" "cv::Matx< float,2,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< float,2,1 > * >(argp2);
result = ((cv::Matx< float,2,1 > const *)arg1)->div((cv::Matx< float,2,1 > const &)*arg2);
resultobj = SWIG_NewPointerObj((new cv::Matx< float,2,1 >(static_cast< const cv::Matx< float,2,1 >& >(result))), SWIGTYPE_p_cv__MatxT_float_2_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_float_2_1___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< float,2,1 > *arg1 = (cv::Matx< float,2,1 > *) 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 ;
float *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:_Matx_float_2_1___call__",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_float_2_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_float_2_1___call__" "', argument " "1"" of type '" "cv::Matx< float,2,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< float,2,1 > * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_Matx_float_2_1___call__" "', 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 '" "_Matx_float_2_1___call__" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
result = (float *) &((cv::Matx< float,2,1 > const *)arg1)->operator ()(arg2,arg3);
resultobj = SWIG_From_float(static_cast< float >(*result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_float_2_1__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< float,2,1 > *arg1 = 0 ;
cv::Matx< float,2,1 > *arg2 = 0 ;
cv::Matx_AddOp 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 ;
cv::Matx< float,2,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Matx_float_2_1",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_float_2_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_float_2_1" "', argument " "1"" of type '" "cv::Matx< float,2,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_float_2_1" "', argument " "1"" of type '" "cv::Matx< float,2,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< float,2,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_float_2_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Matx_float_2_1" "', argument " "2"" of type '" "cv::Matx< float,2,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_float_2_1" "', argument " "2"" of type '" "cv::Matx< float,2,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< float,2,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_AddOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Matx_float_2_1" "', argument " "3"" of type '" "cv::Matx_AddOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_float_2_1" "', argument " "3"" of type '" "cv::Matx_AddOp""'");
} else {
cv::Matx_AddOp * temp = reinterpret_cast< cv::Matx_AddOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Matx< float,2,1 > *)new cv::Matx< float,2,1 >((cv::Matx< float,2,1 > const &)*arg1,(cv::Matx< float,2,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_float_2_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_float_2_1__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< float,2,1 > *arg1 = 0 ;
cv::Matx< float,2,1 > *arg2 = 0 ;
cv::Matx_SubOp 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 ;
cv::Matx< float,2,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Matx_float_2_1",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_float_2_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_float_2_1" "', argument " "1"" of type '" "cv::Matx< float,2,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_float_2_1" "', argument " "1"" of type '" "cv::Matx< float,2,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< float,2,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_float_2_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Matx_float_2_1" "', argument " "2"" of type '" "cv::Matx< float,2,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_float_2_1" "', argument " "2"" of type '" "cv::Matx< float,2,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< float,2,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_SubOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Matx_float_2_1" "', argument " "3"" of type '" "cv::Matx_SubOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_float_2_1" "', argument " "3"" of type '" "cv::Matx_SubOp""'");
} else {
cv::Matx_SubOp * temp = reinterpret_cast< cv::Matx_SubOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Matx< float,2,1 > *)new cv::Matx< float,2,1 >((cv::Matx< float,2,1 > const &)*arg1,(cv::Matx< float,2,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_float_2_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_float_2_1__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< float,2,1 > *arg1 = 0 ;
cv::Matx< float,2,1 > *arg2 = 0 ;
cv::Matx_MulOp 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 ;
cv::Matx< float,2,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Matx_float_2_1",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_float_2_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_float_2_1" "', argument " "1"" of type '" "cv::Matx< float,2,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_float_2_1" "', argument " "1"" of type '" "cv::Matx< float,2,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< float,2,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_float_2_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Matx_float_2_1" "', argument " "2"" of type '" "cv::Matx< float,2,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_float_2_1" "', argument " "2"" of type '" "cv::Matx< float,2,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< float,2,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_MulOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Matx_float_2_1" "', argument " "3"" of type '" "cv::Matx_MulOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_float_2_1" "', argument " "3"" of type '" "cv::Matx_MulOp""'");
} else {
cv::Matx_MulOp * temp = reinterpret_cast< cv::Matx_MulOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Matx< float,2,1 > *)new cv::Matx< float,2,1 >((cv::Matx< float,2,1 > const &)*arg1,(cv::Matx< float,2,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_float_2_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_float_2_1__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< float,2,1 > *arg1 = 0 ;
cv::Matx< float,2,1 > *arg2 = 0 ;
cv::Matx_DivOp 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 ;
cv::Matx< float,2,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Matx_float_2_1",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_float_2_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_float_2_1" "', argument " "1"" of type '" "cv::Matx< float,2,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_float_2_1" "', argument " "1"" of type '" "cv::Matx< float,2,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< float,2,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_float_2_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Matx_float_2_1" "', argument " "2"" of type '" "cv::Matx< float,2,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_float_2_1" "', argument " "2"" of type '" "cv::Matx< float,2,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< float,2,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_DivOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Matx_float_2_1" "', argument " "3"" of type '" "cv::Matx_DivOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_float_2_1" "', argument " "3"" of type '" "cv::Matx_DivOp""'");
} else {
cv::Matx_DivOp * temp = reinterpret_cast< cv::Matx_DivOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Matx< float,2,1 > *)new cv::Matx< float,2,1 >((cv::Matx< float,2,1 > const &)*arg1,(cv::Matx< float,2,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_float_2_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_float_2_1__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< float,1,2 > *arg1 = 0 ;
cv::Matx_TOp arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
cv::Matx< float,2,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:new__Matx_float_2_1",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_float_1_2_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_float_2_1" "', argument " "1"" of type '" "cv::Matx< float,1,2 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_float_2_1" "', argument " "1"" of type '" "cv::Matx< float,1,2 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< float,1,2 > * >(argp1);
{
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__Matx_TOp, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Matx_float_2_1" "', argument " "2"" of type '" "cv::Matx_TOp""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_float_2_1" "', argument " "2"" of type '" "cv::Matx_TOp""'");
} else {
cv::Matx_TOp * temp = reinterpret_cast< cv::Matx_TOp * >(argp2);
arg2 = *temp;
if (SWIG_IsNewObj(res2)) delete temp;
}
}
result = (cv::Matx< float,2,1 > *)new cv::Matx< float,2,1 >((cv::Matx< float,1,2 > const &)*arg1,arg2);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_float_2_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_float_2_1_val_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< float,2,1 > *arg1 = (cv::Matx< float,2,1 > *) 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:_Matx_float_2_1_val_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_float_2_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_float_2_1_val_set" "', argument " "1"" of type '" "cv::Matx< float,2,1 > *""'");
}
arg1 = reinterpret_cast< cv::Matx< float,2,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_float, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_float_2_1_val_set" "', argument " "2"" of type '" "float [2*1]""'");
}
arg2 = reinterpret_cast< float * >(argp2);
{
if (arg2) {
size_t ii = 0;
for (; ii < (size_t)2*1; ++ii) *(float *)&arg1->val[ii] = *((float *)arg2 + ii);
} else {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""val""' of type '""float [2*1]""'");
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_float_2_1_val_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< float,2,1 > *arg1 = (cv::Matx< float,2,1 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
float *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:_Matx_float_2_1_val_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_float_2_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_float_2_1_val_get" "', argument " "1"" of type '" "cv::Matx< float,2,1 > *""'");
}
arg1 = reinterpret_cast< cv::Matx< float,2,1 > * >(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_new__Matx_float_2_1__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< cv::Matx< float,2,1 >::value_type,std::allocator< cv::Matx< float,2,1 >::value_type > > arg1 ;
PyObject * obj0 = 0 ;
cv::Matx< float,2,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__Matx_float_2_1",&obj0)) SWIG_fail;
{
std::vector< float,std::allocator< float > > *ptr = (std::vector< float,std::allocator< float > > *)0;
int res = swig::asptr(obj0, &ptr);
if (!SWIG_IsOK(res) || !ptr) {
SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new__Matx_float_2_1" "', argument " "1"" of type '" "std::vector< cv::Matx< float,2,1 >::value_type,std::allocator< cv::Matx< float,2,1 >::value_type > >""'");
}
arg1 = *ptr;
if (SWIG_IsNewObj(res)) delete ptr;
}
result = (cv::Matx< float,2,1 > *)new_cv_Matx_Sl_float_Sc_2_Sc_1_Sg___SWIG_6(arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_float_2_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_float_2_1(PyObject *self, PyObject *args) {
Py_ssize_t argc;
PyObject *argv[4] = {
0
};
Py_ssize_t ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = args ? PyObject_Length(args) : 0;
for (ii = 0; (ii < 3) && (ii < argc); 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_float, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_float_2_1__SWIG_0(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__Matx_float_2_1__SWIG_6(self, args);
}
}
if (argc == 2) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_float_1_2_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__Matx_TOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_float_2_1__SWIG_5(self, args);
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_float_2_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_float_2_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_MulOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_float_2_1__SWIG_3(self, args);
}
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_float_2_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_float_2_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_DivOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_float_2_1__SWIG_4(self, args);
}
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_float_2_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_float_2_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_AddOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_float_2_1__SWIG_1(self, args);
}
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_float_2_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_float_2_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_SubOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_float_2_1__SWIG_2(self, args);
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new__Matx_float_2_1'.\n"
" Possible C/C++ prototypes are:\n"
" cv::Matx< float,2,1 >::Matx(float const *)\n"
" cv::Matx< float,2,1 >::Matx(cv::Matx< float,2,1 > const &,cv::Matx< float,2,1 > const &,cv::Matx_AddOp)\n"
" cv::Matx< float,2,1 >::Matx(cv::Matx< float,2,1 > const &,cv::Matx< float,2,1 > const &,cv::Matx_SubOp)\n"
" cv::Matx< float,2,1 >::Matx(cv::Matx< float,2,1 > const &,cv::Matx< float,2,1 > const &,cv::Matx_MulOp)\n"
" cv::Matx< float,2,1 >::Matx(cv::Matx< float,2,1 > const &,cv::Matx< float,2,1 > const &,cv::Matx_DivOp)\n"
" cv::Matx< float,2,1 >::Matx(cv::Matx< float,1,2 > const &,cv::Matx_TOp)\n"
" cv::Matx< float,2,1 >::Matx(std::vector< cv::Matx< float,2,1 >::value_type,std::allocator< cv::Matx< float,2,1 >::value_type > >)\n");
return 0;
}
SWIGINTERN PyObject *_wrap__Matx_float_2_1___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< float,2,1 > *arg1 = (cv::Matx< float,2,1 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
std::string result;
if (!PyArg_ParseTuple(args,(char *)"O:_Matx_float_2_1___str__",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_float_2_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_float_2_1___str__" "', argument " "1"" of type '" "cv::Matx< float,2,1 > *""'");
}
arg1 = reinterpret_cast< cv::Matx< float,2,1 > * >(argp1);
result = cv_Matx_Sl_float_Sc_2_Sc_1_Sg____str__(arg1);
resultobj = SWIG_From_std_string(static_cast< std::string >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete__Matx_float_2_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< float,2,1 > *arg1 = (cv::Matx< float,2,1 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete__Matx_float_2_1",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_float_2_1_t, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__Matx_float_2_1" "', argument " "1"" of type '" "cv::Matx< float,2,1 > *""'");
}
arg1 = reinterpret_cast< cv::Matx< float,2,1 > * >(argp1);
delete arg1;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_Matx_float_2_1_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_cv__MatxT_float_2_1_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_new__Vec_float_2__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
float *arg1 = (float *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
cv::Vec< float,2 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__Vec_float_2",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_float, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Vec_float_2" "', argument " "1"" of type '" "float const *""'");
}
arg1 = reinterpret_cast< float * >(argp1);
result = (cv::Vec< float,2 > *)new cv::Vec< float,2 >((float const *)arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__VecT_float_2_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Vec_float_2__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Vec< float,2 > *arg1 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
cv::Vec< float,2 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__Vec_float_2",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__VecT_float_2_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Vec_float_2" "', argument " "1"" of type '" "cv::Vec< float,2 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_float_2" "', argument " "1"" of type '" "cv::Vec< float,2 > const &""'");
}
arg1 = reinterpret_cast< cv::Vec< float,2 > * >(argp1);
result = (cv::Vec< float,2 > *)new cv::Vec< float,2 >((cv::Vec< float,2 > const &)*arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__VecT_float_2_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Vec_float_2_all(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
float arg1 ;
float val1 ;
int ecode1 = 0 ;
PyObject * obj0 = 0 ;
SwigValueWrapper< cv::Vec< float,2 > > result;
if (!PyArg_ParseTuple(args,(char *)"O:_Vec_float_2_all",&obj0)) SWIG_fail;
ecode1 = SWIG_AsVal_float(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_Vec_float_2_all" "', argument " "1"" of type '" "float""'");
}
arg1 = static_cast< float >(val1);
result = cv::Vec< float,2 >::SWIGTEMPLATEDISAMBIGUATOR all(arg1);
resultobj = SWIG_NewPointerObj((new cv::Vec< float,2 >(static_cast< const cv::Vec< float,2 >& >(result))), SWIGTYPE_p_cv__VecT_float_2_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Vec_float_2_mul(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Vec< float,2 > *arg1 = (cv::Vec< float,2 > *) 0 ;
cv::Vec< float,2 > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
SwigValueWrapper< cv::Vec< float,2 > > result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Vec_float_2_mul",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__VecT_float_2_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Vec_float_2_mul" "', argument " "1"" of type '" "cv::Vec< float,2 > const *""'");
}
arg1 = reinterpret_cast< cv::Vec< float,2 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__VecT_float_2_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Vec_float_2_mul" "', argument " "2"" of type '" "cv::Vec< float,2 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Vec_float_2_mul" "', argument " "2"" of type '" "cv::Vec< float,2 > const &""'");
}
arg2 = reinterpret_cast< cv::Vec< float,2 > * >(argp2);
result = ((cv::Vec< float,2 > const *)arg1)->mul((cv::Vec< float,2 > const &)*arg2);
resultobj = SWIG_NewPointerObj((new cv::Vec< float,2 >(static_cast< const cv::Vec< float,2 >& >(result))), SWIGTYPE_p_cv__VecT_float_2_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Vec_float_2___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Vec< float,2 > *arg1 = (cv::Vec< 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:_Vec_float_2___call__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__VecT_float_2_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Vec_float_2___call__" "', argument " "1"" of type '" "cv::Vec< float,2 > const *""'");
}
arg1 = reinterpret_cast< cv::Vec< float,2 > * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_Vec_float_2___call__" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
result = (float *) &((cv::Vec< float,2 > const *)arg1)->operator ()(arg2);
resultobj = SWIG_From_float(static_cast< float >(*result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Vec_float_2__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< float,2,1 > *arg1 = 0 ;
cv::Matx< float,2,1 > *arg2 = 0 ;
cv::Matx_AddOp 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 ;
cv::Vec< float,2 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Vec_float_2",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_float_2_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Vec_float_2" "', argument " "1"" of type '" "cv::Matx< float,2,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_float_2" "', argument " "1"" of type '" "cv::Matx< float,2,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< float,2,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_float_2_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Vec_float_2" "', argument " "2"" of type '" "cv::Matx< float,2,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_float_2" "', argument " "2"" of type '" "cv::Matx< float,2,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< float,2,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_AddOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Vec_float_2" "', argument " "3"" of type '" "cv::Matx_AddOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_float_2" "', argument " "3"" of type '" "cv::Matx_AddOp""'");
} else {
cv::Matx_AddOp * temp = reinterpret_cast< cv::Matx_AddOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Vec< float,2 > *)new cv::Vec< float,2 >((cv::Matx< float,2,1 > const &)*arg1,(cv::Matx< float,2,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__VecT_float_2_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Vec_float_2__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< float,2,1 > *arg1 = 0 ;
cv::Matx< float,2,1 > *arg2 = 0 ;
cv::Matx_SubOp 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 ;
cv::Vec< float,2 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Vec_float_2",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_float_2_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Vec_float_2" "', argument " "1"" of type '" "cv::Matx< float,2,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_float_2" "', argument " "1"" of type '" "cv::Matx< float,2,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< float,2,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_float_2_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Vec_float_2" "', argument " "2"" of type '" "cv::Matx< float,2,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_float_2" "', argument " "2"" of type '" "cv::Matx< float,2,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< float,2,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_SubOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Vec_float_2" "', argument " "3"" of type '" "cv::Matx_SubOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_float_2" "', argument " "3"" of type '" "cv::Matx_SubOp""'");
} else {
cv::Matx_SubOp * temp = reinterpret_cast< cv::Matx_SubOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Vec< float,2 > *)new cv::Vec< float,2 >((cv::Matx< float,2,1 > const &)*arg1,(cv::Matx< float,2,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__VecT_float_2_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Vec_float_2__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< cv::Vec< float,2 >::value_type,std::allocator< cv::Vec< float,2 >::value_type > > arg1 ;
PyObject * obj0 = 0 ;
cv::Vec< float,2 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__Vec_float_2",&obj0)) SWIG_fail;
{
std::vector< float,std::allocator< float > > *ptr = (std::vector< float,std::allocator< float > > *)0;
int res = swig::asptr(obj0, &ptr);
if (!SWIG_IsOK(res) || !ptr) {
SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new__Vec_float_2" "', argument " "1"" of type '" "std::vector< cv::Vec< float,2 >::value_type,std::allocator< cv::Vec< float,2 >::value_type > >""'");
}
arg1 = *ptr;
if (SWIG_IsNewObj(res)) delete ptr;
}
result = (cv::Vec< float,2 > *)new_cv_Vec_Sl_float_Sc_2_Sg___SWIG_4(arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__VecT_float_2_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Vec_float_2(PyObject *self, PyObject *args) {
Py_ssize_t argc;
PyObject *argv[4] = {
0
};
Py_ssize_t ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = args ? PyObject_Length(args) : 0;
for (ii = 0; (ii < 3) && (ii < argc); 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_float, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Vec_float_2__SWIG_0(self, args);
}
}
if (argc == 1) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__VecT_float_2_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Vec_float_2__SWIG_1(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__Vec_float_2__SWIG_4(self, args);
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_float_2_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_float_2_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_SubOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Vec_float_2__SWIG_3(self, args);
}
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_float_2_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_float_2_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_AddOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Vec_float_2__SWIG_2(self, args);
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new__Vec_float_2'.\n"
" Possible C/C++ prototypes are:\n"
" cv::Vec< float,2 >::Vec(float const *)\n"
" cv::Vec< float,2 >::Vec(cv::Vec< float,2 > const &)\n"
" cv::Vec< float,2 >::Vec(cv::Matx< float,2,1 > const &,cv::Matx< float,2,1 > const &,cv::Matx_AddOp)\n"
" cv::Vec< float,2 >::Vec(cv::Matx< float,2,1 > const &,cv::Matx< float,2,1 > const &,cv::Matx_SubOp)\n"
" cv::Vec< float,2 >::Vec(std::vector< cv::Vec< float,2 >::value_type,std::allocator< cv::Vec< float,2 >::value_type > >)\n");
return 0;
}
SWIGINTERN PyObject *_wrap__Vec_float_2___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Vec< float,2 > *arg1 = (cv::Vec< float,2 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
std::string result;
if (!PyArg_ParseTuple(args,(char *)"O:_Vec_float_2___str__",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__VecT_float_2_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Vec_float_2___str__" "', argument " "1"" of type '" "cv::Vec< float,2 > *""'");
}
arg1 = reinterpret_cast< cv::Vec< float,2 > * >(argp1);
result = cv_Vec_Sl_float_Sc_2_Sg____str__(arg1);
resultobj = SWIG_From_std_string(static_cast< std::string >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete__Vec_float_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Vec< float,2 > *arg1 = (cv::Vec< float,2 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete__Vec_float_2",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__VecT_float_2_t, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__Vec_float_2" "', argument " "1"" of type '" "cv::Vec< float,2 > *""'");
}
arg1 = reinterpret_cast< cv::Vec< float,2 > * >(argp1);
delete arg1;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_Vec_float_2_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_cv__VecT_float_2_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_new__DataType_Vec_float_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::DataType< cv::Vec< float,2 > > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new__DataType_Vec_float_2")) SWIG_fail;
result = (cv::DataType< cv::Vec< float,2 > > *)new cv::DataType< cv::Vec< float,2 > >();
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__DataTypeT_cv__VecT_float_2_t_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete__DataType_Vec_float_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::DataType< cv::Vec< float,2 > > *arg1 = (cv::DataType< cv::Vec< float,2 > > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete__DataType_Vec_float_2",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__DataTypeT_cv__VecT_float_2_t_t, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__DataType_Vec_float_2" "', argument " "1"" of type '" "cv::DataType< cv::Vec< float,2 > > *""'");
}
arg1 = reinterpret_cast< cv::DataType< cv::Vec< float,2 > > * >(argp1);
delete arg1;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_DataType_Vec_float_2_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_cv__DataTypeT_cv__VecT_float_2_t_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_new__Matx_float_3_1__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
float *arg1 = (float *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
cv::Matx< float,3,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__Matx_float_3_1",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_float, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_float_3_1" "', argument " "1"" of type '" "float const *""'");
}
arg1 = reinterpret_cast< float * >(argp1);
result = (cv::Matx< float,3,1 > *)new cv::Matx< float,3,1 >((float const *)arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_float_3_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_float_3_1_all(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
float arg1 ;
float val1 ;
int ecode1 = 0 ;
PyObject * obj0 = 0 ;
SwigValueWrapper< cv::Matx< float,3,1 > > result;
if (!PyArg_ParseTuple(args,(char *)"O:_Matx_float_3_1_all",&obj0)) SWIG_fail;
ecode1 = SWIG_AsVal_float(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_Matx_float_3_1_all" "', argument " "1"" of type '" "float""'");
}
arg1 = static_cast< float >(val1);
result = cv::Matx< float,3,1 >::SWIGTEMPLATEDISAMBIGUATOR all(arg1);
resultobj = SWIG_NewPointerObj((new cv::Matx< float,3,1 >(static_cast< const cv::Matx< float,3,1 >& >(result))), SWIGTYPE_p_cv__MatxT_float_3_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_float_3_1_zeros(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
SwigValueWrapper< cv::Matx< float,3,1 > > result;
if (!PyArg_ParseTuple(args,(char *)":_Matx_float_3_1_zeros")) SWIG_fail;
result = cv::Matx< float,3,1 >::SWIGTEMPLATEDISAMBIGUATOR zeros();
resultobj = SWIG_NewPointerObj((new cv::Matx< float,3,1 >(static_cast< const cv::Matx< float,3,1 >& >(result))), SWIGTYPE_p_cv__MatxT_float_3_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_float_3_1_ones(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
SwigValueWrapper< cv::Matx< float,3,1 > > result;
if (!PyArg_ParseTuple(args,(char *)":_Matx_float_3_1_ones")) SWIG_fail;
result = cv::Matx< float,3,1 >::SWIGTEMPLATEDISAMBIGUATOR ones();
resultobj = SWIG_NewPointerObj((new cv::Matx< float,3,1 >(static_cast< const cv::Matx< float,3,1 >& >(result))), SWIGTYPE_p_cv__MatxT_float_3_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_float_3_1_eye(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
SwigValueWrapper< cv::Matx< float,3,1 > > result;
if (!PyArg_ParseTuple(args,(char *)":_Matx_float_3_1_eye")) SWIG_fail;
result = cv::Matx< float,3,1 >::SWIGTEMPLATEDISAMBIGUATOR eye();
resultobj = SWIG_NewPointerObj((new cv::Matx< float,3,1 >(static_cast< const cv::Matx< float,3,1 >& >(result))), SWIGTYPE_p_cv__MatxT_float_3_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_float_3_1_randu(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 ;
SwigValueWrapper< cv::Matx< float,3,1 > > result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_float_3_1_randu",&obj0,&obj1)) SWIG_fail;
ecode1 = SWIG_AsVal_float(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_Matx_float_3_1_randu" "', 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 '" "_Matx_float_3_1_randu" "', argument " "2"" of type '" "float""'");
}
arg2 = static_cast< float >(val2);
result = cv::Matx< float,3,1 >::SWIGTEMPLATEDISAMBIGUATOR randu(arg1,arg2);
resultobj = SWIG_NewPointerObj((new cv::Matx< float,3,1 >(static_cast< const cv::Matx< float,3,1 >& >(result))), SWIGTYPE_p_cv__MatxT_float_3_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_float_3_1_randn(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 ;
SwigValueWrapper< cv::Matx< float,3,1 > > result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_float_3_1_randn",&obj0,&obj1)) SWIG_fail;
ecode1 = SWIG_AsVal_float(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_Matx_float_3_1_randn" "', 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 '" "_Matx_float_3_1_randn" "', argument " "2"" of type '" "float""'");
}
arg2 = static_cast< float >(val2);
result = cv::Matx< float,3,1 >::SWIGTEMPLATEDISAMBIGUATOR randn(arg1,arg2);
resultobj = SWIG_NewPointerObj((new cv::Matx< float,3,1 >(static_cast< const cv::Matx< float,3,1 >& >(result))), SWIGTYPE_p_cv__MatxT_float_3_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_float_3_1_dot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< float,3,1 > *arg1 = (cv::Matx< float,3,1 > *) 0 ;
cv::Matx< float,3,1 > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
float result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_float_3_1_dot",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_float_3_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_float_3_1_dot" "', argument " "1"" of type '" "cv::Matx< float,3,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< float,3,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_float_3_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_float_3_1_dot" "', argument " "2"" of type '" "cv::Matx< float,3,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Matx_float_3_1_dot" "', argument " "2"" of type '" "cv::Matx< float,3,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< float,3,1 > * >(argp2);
result = (float)((cv::Matx< float,3,1 > const *)arg1)->dot((cv::Matx< float,3,1 > const &)*arg2);
resultobj = SWIG_From_float(static_cast< float >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_float_3_1_ddot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< float,3,1 > *arg1 = (cv::Matx< float,3,1 > *) 0 ;
cv::Matx< float,3,1 > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
double result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_float_3_1_ddot",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_float_3_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_float_3_1_ddot" "', argument " "1"" of type '" "cv::Matx< float,3,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< float,3,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_float_3_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_float_3_1_ddot" "', argument " "2"" of type '" "cv::Matx< float,3,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Matx_float_3_1_ddot" "', argument " "2"" of type '" "cv::Matx< float,3,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< float,3,1 > * >(argp2);
result = (double)((cv::Matx< float,3,1 > const *)arg1)->ddot((cv::Matx< float,3,1 > const &)*arg2);
resultobj = SWIG_From_double(static_cast< double >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_float_3_1_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< float,3,1 > *arg1 = (cv::Matx< float,3,1 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
SwigValueWrapper< cv::Matx< float,1,3 > > result;
if (!PyArg_ParseTuple(args,(char *)"O:_Matx_float_3_1_t",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_float_3_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_float_3_1_t" "', argument " "1"" of type '" "cv::Matx< float,3,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< float,3,1 > * >(argp1);
result = ((cv::Matx< float,3,1 > const *)arg1)->t();
resultobj = SWIG_NewPointerObj((new cv::Matx< float,1,3 >(static_cast< const cv::Matx< float,1,3 >& >(result))), SWIGTYPE_p_cv__MatxT_float_1_3_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_float_3_1_mul(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< float,3,1 > *arg1 = (cv::Matx< float,3,1 > *) 0 ;
cv::Matx< float,3,1 > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
SwigValueWrapper< cv::Matx< float,3,1 > > result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_float_3_1_mul",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_float_3_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_float_3_1_mul" "', argument " "1"" of type '" "cv::Matx< float,3,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< float,3,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_float_3_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_float_3_1_mul" "', argument " "2"" of type '" "cv::Matx< float,3,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Matx_float_3_1_mul" "', argument " "2"" of type '" "cv::Matx< float,3,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< float,3,1 > * >(argp2);
result = ((cv::Matx< float,3,1 > const *)arg1)->mul((cv::Matx< float,3,1 > const &)*arg2);
resultobj = SWIG_NewPointerObj((new cv::Matx< float,3,1 >(static_cast< const cv::Matx< float,3,1 >& >(result))), SWIGTYPE_p_cv__MatxT_float_3_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_float_3_1_div(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< float,3,1 > *arg1 = (cv::Matx< float,3,1 > *) 0 ;
cv::Matx< float,3,1 > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
SwigValueWrapper< cv::Matx< float,3,1 > > result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_float_3_1_div",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_float_3_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_float_3_1_div" "', argument " "1"" of type '" "cv::Matx< float,3,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< float,3,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_float_3_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_float_3_1_div" "', argument " "2"" of type '" "cv::Matx< float,3,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Matx_float_3_1_div" "', argument " "2"" of type '" "cv::Matx< float,3,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< float,3,1 > * >(argp2);
result = ((cv::Matx< float,3,1 > const *)arg1)->div((cv::Matx< float,3,1 > const &)*arg2);
resultobj = SWIG_NewPointerObj((new cv::Matx< float,3,1 >(static_cast< const cv::Matx< float,3,1 >& >(result))), SWIGTYPE_p_cv__MatxT_float_3_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_float_3_1___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< float,3,1 > *arg1 = (cv::Matx< float,3,1 > *) 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 ;
float *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:_Matx_float_3_1___call__",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_float_3_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_float_3_1___call__" "', argument " "1"" of type '" "cv::Matx< float,3,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< float,3,1 > * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_Matx_float_3_1___call__" "', 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 '" "_Matx_float_3_1___call__" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
result = (float *) &((cv::Matx< float,3,1 > const *)arg1)->operator ()(arg2,arg3);
resultobj = SWIG_From_float(static_cast< float >(*result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_float_3_1__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< float,3,1 > *arg1 = 0 ;
cv::Matx< float,3,1 > *arg2 = 0 ;
cv::Matx_AddOp 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 ;
cv::Matx< float,3,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Matx_float_3_1",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_float_3_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_float_3_1" "', argument " "1"" of type '" "cv::Matx< float,3,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_float_3_1" "', argument " "1"" of type '" "cv::Matx< float,3,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< float,3,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_float_3_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Matx_float_3_1" "', argument " "2"" of type '" "cv::Matx< float,3,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_float_3_1" "', argument " "2"" of type '" "cv::Matx< float,3,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< float,3,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_AddOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Matx_float_3_1" "', argument " "3"" of type '" "cv::Matx_AddOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_float_3_1" "', argument " "3"" of type '" "cv::Matx_AddOp""'");
} else {
cv::Matx_AddOp * temp = reinterpret_cast< cv::Matx_AddOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Matx< float,3,1 > *)new cv::Matx< float,3,1 >((cv::Matx< float,3,1 > const &)*arg1,(cv::Matx< float,3,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_float_3_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_float_3_1__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< float,3,1 > *arg1 = 0 ;
cv::Matx< float,3,1 > *arg2 = 0 ;
cv::Matx_SubOp 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 ;
cv::Matx< float,3,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Matx_float_3_1",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_float_3_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_float_3_1" "', argument " "1"" of type '" "cv::Matx< float,3,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_float_3_1" "', argument " "1"" of type '" "cv::Matx< float,3,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< float,3,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_float_3_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Matx_float_3_1" "', argument " "2"" of type '" "cv::Matx< float,3,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_float_3_1" "', argument " "2"" of type '" "cv::Matx< float,3,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< float,3,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_SubOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Matx_float_3_1" "', argument " "3"" of type '" "cv::Matx_SubOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_float_3_1" "', argument " "3"" of type '" "cv::Matx_SubOp""'");
} else {
cv::Matx_SubOp * temp = reinterpret_cast< cv::Matx_SubOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Matx< float,3,1 > *)new cv::Matx< float,3,1 >((cv::Matx< float,3,1 > const &)*arg1,(cv::Matx< float,3,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_float_3_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_float_3_1__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< float,3,1 > *arg1 = 0 ;
cv::Matx< float,3,1 > *arg2 = 0 ;
cv::Matx_MulOp 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 ;
cv::Matx< float,3,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Matx_float_3_1",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_float_3_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_float_3_1" "', argument " "1"" of type '" "cv::Matx< float,3,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_float_3_1" "', argument " "1"" of type '" "cv::Matx< float,3,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< float,3,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_float_3_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Matx_float_3_1" "', argument " "2"" of type '" "cv::Matx< float,3,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_float_3_1" "', argument " "2"" of type '" "cv::Matx< float,3,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< float,3,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_MulOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Matx_float_3_1" "', argument " "3"" of type '" "cv::Matx_MulOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_float_3_1" "', argument " "3"" of type '" "cv::Matx_MulOp""'");
} else {
cv::Matx_MulOp * temp = reinterpret_cast< cv::Matx_MulOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Matx< float,3,1 > *)new cv::Matx< float,3,1 >((cv::Matx< float,3,1 > const &)*arg1,(cv::Matx< float,3,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_float_3_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_float_3_1__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< float,3,1 > *arg1 = 0 ;
cv::Matx< float,3,1 > *arg2 = 0 ;
cv::Matx_DivOp 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 ;
cv::Matx< float,3,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Matx_float_3_1",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_float_3_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_float_3_1" "', argument " "1"" of type '" "cv::Matx< float,3,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_float_3_1" "', argument " "1"" of type '" "cv::Matx< float,3,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< float,3,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_float_3_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Matx_float_3_1" "', argument " "2"" of type '" "cv::Matx< float,3,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_float_3_1" "', argument " "2"" of type '" "cv::Matx< float,3,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< float,3,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_DivOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Matx_float_3_1" "', argument " "3"" of type '" "cv::Matx_DivOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_float_3_1" "', argument " "3"" of type '" "cv::Matx_DivOp""'");
} else {
cv::Matx_DivOp * temp = reinterpret_cast< cv::Matx_DivOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Matx< float,3,1 > *)new cv::Matx< float,3,1 >((cv::Matx< float,3,1 > const &)*arg1,(cv::Matx< float,3,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_float_3_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_float_3_1__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< float,1,3 > *arg1 = 0 ;
cv::Matx_TOp arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
cv::Matx< float,3,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:new__Matx_float_3_1",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_float_1_3_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_float_3_1" "', argument " "1"" of type '" "cv::Matx< float,1,3 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_float_3_1" "', argument " "1"" of type '" "cv::Matx< float,1,3 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< float,1,3 > * >(argp1);
{
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__Matx_TOp, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Matx_float_3_1" "', argument " "2"" of type '" "cv::Matx_TOp""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_float_3_1" "', argument " "2"" of type '" "cv::Matx_TOp""'");
} else {
cv::Matx_TOp * temp = reinterpret_cast< cv::Matx_TOp * >(argp2);
arg2 = *temp;
if (SWIG_IsNewObj(res2)) delete temp;
}
}
result = (cv::Matx< float,3,1 > *)new cv::Matx< float,3,1 >((cv::Matx< float,1,3 > const &)*arg1,arg2);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_float_3_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_float_3_1_val_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< float,3,1 > *arg1 = (cv::Matx< float,3,1 > *) 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:_Matx_float_3_1_val_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_float_3_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_float_3_1_val_set" "', argument " "1"" of type '" "cv::Matx< float,3,1 > *""'");
}
arg1 = reinterpret_cast< cv::Matx< float,3,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_float, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_float_3_1_val_set" "', argument " "2"" of type '" "float [3*1]""'");
}
arg2 = reinterpret_cast< float * >(argp2);
{
if (arg2) {
size_t ii = 0;
for (; ii < (size_t)3*1; ++ii) *(float *)&arg1->val[ii] = *((float *)arg2 + ii);
} else {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""val""' of type '""float [3*1]""'");
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_float_3_1_val_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< float,3,1 > *arg1 = (cv::Matx< float,3,1 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
float *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:_Matx_float_3_1_val_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_float_3_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_float_3_1_val_get" "', argument " "1"" of type '" "cv::Matx< float,3,1 > *""'");
}
arg1 = reinterpret_cast< cv::Matx< float,3,1 > * >(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_new__Matx_float_3_1__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< cv::Matx< float,3,1 >::value_type,std::allocator< cv::Matx< float,3,1 >::value_type > > arg1 ;
PyObject * obj0 = 0 ;
cv::Matx< float,3,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__Matx_float_3_1",&obj0)) SWIG_fail;
{
std::vector< float,std::allocator< float > > *ptr = (std::vector< float,std::allocator< float > > *)0;
int res = swig::asptr(obj0, &ptr);
if (!SWIG_IsOK(res) || !ptr) {
SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new__Matx_float_3_1" "', argument " "1"" of type '" "std::vector< cv::Matx< float,3,1 >::value_type,std::allocator< cv::Matx< float,3,1 >::value_type > >""'");
}
arg1 = *ptr;
if (SWIG_IsNewObj(res)) delete ptr;
}
result = (cv::Matx< float,3,1 > *)new_cv_Matx_Sl_float_Sc_3_Sc_1_Sg___SWIG_6(arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_float_3_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_float_3_1(PyObject *self, PyObject *args) {
Py_ssize_t argc;
PyObject *argv[4] = {
0
};
Py_ssize_t ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = args ? PyObject_Length(args) : 0;
for (ii = 0; (ii < 3) && (ii < argc); 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_float, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_float_3_1__SWIG_0(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__Matx_float_3_1__SWIG_6(self, args);
}
}
if (argc == 2) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_float_1_3_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__Matx_TOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_float_3_1__SWIG_5(self, args);
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_float_3_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_float_3_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_MulOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_float_3_1__SWIG_3(self, args);
}
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_float_3_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_float_3_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_DivOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_float_3_1__SWIG_4(self, args);
}
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_float_3_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_float_3_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_AddOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_float_3_1__SWIG_1(self, args);
}
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_float_3_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_float_3_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_SubOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_float_3_1__SWIG_2(self, args);
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new__Matx_float_3_1'.\n"
" Possible C/C++ prototypes are:\n"
" cv::Matx< float,3,1 >::Matx(float const *)\n"
" cv::Matx< float,3,1 >::Matx(cv::Matx< float,3,1 > const &,cv::Matx< float,3,1 > const &,cv::Matx_AddOp)\n"
" cv::Matx< float,3,1 >::Matx(cv::Matx< float,3,1 > const &,cv::Matx< float,3,1 > const &,cv::Matx_SubOp)\n"
" cv::Matx< float,3,1 >::Matx(cv::Matx< float,3,1 > const &,cv::Matx< float,3,1 > const &,cv::Matx_MulOp)\n"
" cv::Matx< float,3,1 >::Matx(cv::Matx< float,3,1 > const &,cv::Matx< float,3,1 > const &,cv::Matx_DivOp)\n"
" cv::Matx< float,3,1 >::Matx(cv::Matx< float,1,3 > const &,cv::Matx_TOp)\n"
" cv::Matx< float,3,1 >::Matx(std::vector< cv::Matx< float,3,1 >::value_type,std::allocator< cv::Matx< float,3,1 >::value_type > >)\n");
return 0;
}
SWIGINTERN PyObject *_wrap__Matx_float_3_1___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< float,3,1 > *arg1 = (cv::Matx< float,3,1 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
std::string result;
if (!PyArg_ParseTuple(args,(char *)"O:_Matx_float_3_1___str__",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_float_3_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_float_3_1___str__" "', argument " "1"" of type '" "cv::Matx< float,3,1 > *""'");
}
arg1 = reinterpret_cast< cv::Matx< float,3,1 > * >(argp1);
result = cv_Matx_Sl_float_Sc_3_Sc_1_Sg____str__(arg1);
resultobj = SWIG_From_std_string(static_cast< std::string >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete__Matx_float_3_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< float,3,1 > *arg1 = (cv::Matx< float,3,1 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete__Matx_float_3_1",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_float_3_1_t, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__Matx_float_3_1" "', argument " "1"" of type '" "cv::Matx< float,3,1 > *""'");
}
arg1 = reinterpret_cast< cv::Matx< float,3,1 > * >(argp1);
delete arg1;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_Matx_float_3_1_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_cv__MatxT_float_3_1_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_new__Vec_float_3__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
float *arg1 = (float *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
cv::Vec< float,3 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__Vec_float_3",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_float, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Vec_float_3" "', argument " "1"" of type '" "float const *""'");
}
arg1 = reinterpret_cast< float * >(argp1);
result = (cv::Vec< float,3 > *)new cv::Vec< float,3 >((float const *)arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__VecT_float_3_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Vec_float_3__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Vec< float,3 > *arg1 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
cv::Vec< float,3 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__Vec_float_3",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__VecT_float_3_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Vec_float_3" "', argument " "1"" of type '" "cv::Vec< float,3 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_float_3" "', argument " "1"" of type '" "cv::Vec< float,3 > const &""'");
}
arg1 = reinterpret_cast< cv::Vec< float,3 > * >(argp1);
result = (cv::Vec< float,3 > *)new cv::Vec< float,3 >((cv::Vec< float,3 > const &)*arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__VecT_float_3_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Vec_float_3_all(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
float arg1 ;
float val1 ;
int ecode1 = 0 ;
PyObject * obj0 = 0 ;
SwigValueWrapper< cv::Vec< float,3 > > result;
if (!PyArg_ParseTuple(args,(char *)"O:_Vec_float_3_all",&obj0)) SWIG_fail;
ecode1 = SWIG_AsVal_float(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_Vec_float_3_all" "', argument " "1"" of type '" "float""'");
}
arg1 = static_cast< float >(val1);
result = cv::Vec< float,3 >::SWIGTEMPLATEDISAMBIGUATOR all(arg1);
resultobj = SWIG_NewPointerObj((new cv::Vec< float,3 >(static_cast< const cv::Vec< float,3 >& >(result))), SWIGTYPE_p_cv__VecT_float_3_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Vec_float_3_mul(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Vec< float,3 > *arg1 = (cv::Vec< float,3 > *) 0 ;
cv::Vec< float,3 > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
SwigValueWrapper< cv::Vec< float,3 > > result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Vec_float_3_mul",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__VecT_float_3_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Vec_float_3_mul" "', argument " "1"" of type '" "cv::Vec< float,3 > const *""'");
}
arg1 = reinterpret_cast< cv::Vec< float,3 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__VecT_float_3_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Vec_float_3_mul" "', argument " "2"" of type '" "cv::Vec< float,3 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Vec_float_3_mul" "', argument " "2"" of type '" "cv::Vec< float,3 > const &""'");
}
arg2 = reinterpret_cast< cv::Vec< float,3 > * >(argp2);
result = ((cv::Vec< float,3 > const *)arg1)->mul((cv::Vec< float,3 > const &)*arg2);
resultobj = SWIG_NewPointerObj((new cv::Vec< float,3 >(static_cast< const cv::Vec< float,3 >& >(result))), SWIGTYPE_p_cv__VecT_float_3_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Vec_float_3___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Vec< float,3 > *arg1 = (cv::Vec< 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:_Vec_float_3___call__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__VecT_float_3_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Vec_float_3___call__" "', argument " "1"" of type '" "cv::Vec< float,3 > const *""'");
}
arg1 = reinterpret_cast< cv::Vec< float,3 > * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_Vec_float_3___call__" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
result = (float *) &((cv::Vec< float,3 > const *)arg1)->operator ()(arg2);
resultobj = SWIG_From_float(static_cast< float >(*result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Vec_float_3__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< float,3,1 > *arg1 = 0 ;
cv::Matx< float,3,1 > *arg2 = 0 ;
cv::Matx_AddOp 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 ;
cv::Vec< float,3 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Vec_float_3",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_float_3_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Vec_float_3" "', argument " "1"" of type '" "cv::Matx< float,3,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_float_3" "', argument " "1"" of type '" "cv::Matx< float,3,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< float,3,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_float_3_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Vec_float_3" "', argument " "2"" of type '" "cv::Matx< float,3,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_float_3" "', argument " "2"" of type '" "cv::Matx< float,3,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< float,3,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_AddOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Vec_float_3" "', argument " "3"" of type '" "cv::Matx_AddOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_float_3" "', argument " "3"" of type '" "cv::Matx_AddOp""'");
} else {
cv::Matx_AddOp * temp = reinterpret_cast< cv::Matx_AddOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Vec< float,3 > *)new cv::Vec< float,3 >((cv::Matx< float,3,1 > const &)*arg1,(cv::Matx< float,3,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__VecT_float_3_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Vec_float_3__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< float,3,1 > *arg1 = 0 ;
cv::Matx< float,3,1 > *arg2 = 0 ;
cv::Matx_SubOp 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 ;
cv::Vec< float,3 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Vec_float_3",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_float_3_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Vec_float_3" "', argument " "1"" of type '" "cv::Matx< float,3,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_float_3" "', argument " "1"" of type '" "cv::Matx< float,3,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< float,3,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_float_3_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Vec_float_3" "', argument " "2"" of type '" "cv::Matx< float,3,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_float_3" "', argument " "2"" of type '" "cv::Matx< float,3,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< float,3,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_SubOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Vec_float_3" "', argument " "3"" of type '" "cv::Matx_SubOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_float_3" "', argument " "3"" of type '" "cv::Matx_SubOp""'");
} else {
cv::Matx_SubOp * temp = reinterpret_cast< cv::Matx_SubOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Vec< float,3 > *)new cv::Vec< float,3 >((cv::Matx< float,3,1 > const &)*arg1,(cv::Matx< float,3,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__VecT_float_3_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Vec_float_3__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< cv::Vec< float,3 >::value_type,std::allocator< cv::Vec< float,3 >::value_type > > arg1 ;
PyObject * obj0 = 0 ;
cv::Vec< float,3 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__Vec_float_3",&obj0)) SWIG_fail;
{
std::vector< float,std::allocator< float > > *ptr = (std::vector< float,std::allocator< float > > *)0;
int res = swig::asptr(obj0, &ptr);
if (!SWIG_IsOK(res) || !ptr) {
SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new__Vec_float_3" "', argument " "1"" of type '" "std::vector< cv::Vec< float,3 >::value_type,std::allocator< cv::Vec< float,3 >::value_type > >""'");
}
arg1 = *ptr;
if (SWIG_IsNewObj(res)) delete ptr;
}
result = (cv::Vec< float,3 > *)new_cv_Vec_Sl_float_Sc_3_Sg___SWIG_4(arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__VecT_float_3_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Vec_float_3(PyObject *self, PyObject *args) {
Py_ssize_t argc;
PyObject *argv[4] = {
0
};
Py_ssize_t ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = args ? PyObject_Length(args) : 0;
for (ii = 0; (ii < 3) && (ii < argc); 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_float, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Vec_float_3__SWIG_0(self, args);
}
}
if (argc == 1) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__VecT_float_3_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Vec_float_3__SWIG_1(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__Vec_float_3__SWIG_4(self, args);
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_float_3_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_float_3_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_SubOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Vec_float_3__SWIG_3(self, args);
}
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_float_3_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_float_3_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_AddOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Vec_float_3__SWIG_2(self, args);
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new__Vec_float_3'.\n"
" Possible C/C++ prototypes are:\n"
" cv::Vec< float,3 >::Vec(float const *)\n"
" cv::Vec< float,3 >::Vec(cv::Vec< float,3 > const &)\n"
" cv::Vec< float,3 >::Vec(cv::Matx< float,3,1 > const &,cv::Matx< float,3,1 > const &,cv::Matx_AddOp)\n"
" cv::Vec< float,3 >::Vec(cv::Matx< float,3,1 > const &,cv::Matx< float,3,1 > const &,cv::Matx_SubOp)\n"
" cv::Vec< float,3 >::Vec(std::vector< cv::Vec< float,3 >::value_type,std::allocator< cv::Vec< float,3 >::value_type > >)\n");
return 0;
}
SWIGINTERN PyObject *_wrap__Vec_float_3___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Vec< float,3 > *arg1 = (cv::Vec< float,3 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
std::string result;
if (!PyArg_ParseTuple(args,(char *)"O:_Vec_float_3___str__",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__VecT_float_3_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Vec_float_3___str__" "', argument " "1"" of type '" "cv::Vec< float,3 > *""'");
}
arg1 = reinterpret_cast< cv::Vec< float,3 > * >(argp1);
result = cv_Vec_Sl_float_Sc_3_Sg____str__(arg1);
resultobj = SWIG_From_std_string(static_cast< std::string >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete__Vec_float_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Vec< float,3 > *arg1 = (cv::Vec< float,3 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete__Vec_float_3",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__VecT_float_3_t, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__Vec_float_3" "', argument " "1"" of type '" "cv::Vec< float,3 > *""'");
}
arg1 = reinterpret_cast< cv::Vec< float,3 > * >(argp1);
delete arg1;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_Vec_float_3_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_cv__VecT_float_3_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_new__DataType_Vec_float_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::DataType< cv::Vec< float,3 > > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new__DataType_Vec_float_3")) SWIG_fail;
result = (cv::DataType< cv::Vec< float,3 > > *)new cv::DataType< cv::Vec< float,3 > >();
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__DataTypeT_cv__VecT_float_3_t_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete__DataType_Vec_float_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::DataType< cv::Vec< float,3 > > *arg1 = (cv::DataType< cv::Vec< float,3 > > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete__DataType_Vec_float_3",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__DataTypeT_cv__VecT_float_3_t_t, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__DataType_Vec_float_3" "', argument " "1"" of type '" "cv::DataType< cv::Vec< float,3 > > *""'");
}
arg1 = reinterpret_cast< cv::DataType< cv::Vec< float,3 > > * >(argp1);
delete arg1;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_DataType_Vec_float_3_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_cv__DataTypeT_cv__VecT_float_3_t_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_new__Matx_float_4_1__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
float *arg1 = (float *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
cv::Matx< float,4,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__Matx_float_4_1",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_float, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_float_4_1" "', argument " "1"" of type '" "float const *""'");
}
arg1 = reinterpret_cast< float * >(argp1);
result = (cv::Matx< float,4,1 > *)new cv::Matx< float,4,1 >((float const *)arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_float_4_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_float_4_1_all(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
float arg1 ;
float val1 ;
int ecode1 = 0 ;
PyObject * obj0 = 0 ;
SwigValueWrapper< cv::Matx< float,4,1 > > result;
if (!PyArg_ParseTuple(args,(char *)"O:_Matx_float_4_1_all",&obj0)) SWIG_fail;
ecode1 = SWIG_AsVal_float(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_Matx_float_4_1_all" "', argument " "1"" of type '" "float""'");
}
arg1 = static_cast< float >(val1);
result = cv::Matx< float,4,1 >::SWIGTEMPLATEDISAMBIGUATOR all(arg1);
resultobj = SWIG_NewPointerObj((new cv::Matx< float,4,1 >(static_cast< const cv::Matx< float,4,1 >& >(result))), SWIGTYPE_p_cv__MatxT_float_4_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_float_4_1_zeros(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
SwigValueWrapper< cv::Matx< float,4,1 > > result;
if (!PyArg_ParseTuple(args,(char *)":_Matx_float_4_1_zeros")) SWIG_fail;
result = cv::Matx< float,4,1 >::SWIGTEMPLATEDISAMBIGUATOR zeros();
resultobj = SWIG_NewPointerObj((new cv::Matx< float,4,1 >(static_cast< const cv::Matx< float,4,1 >& >(result))), SWIGTYPE_p_cv__MatxT_float_4_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_float_4_1_ones(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
SwigValueWrapper< cv::Matx< float,4,1 > > result;
if (!PyArg_ParseTuple(args,(char *)":_Matx_float_4_1_ones")) SWIG_fail;
result = cv::Matx< float,4,1 >::SWIGTEMPLATEDISAMBIGUATOR ones();
resultobj = SWIG_NewPointerObj((new cv::Matx< float,4,1 >(static_cast< const cv::Matx< float,4,1 >& >(result))), SWIGTYPE_p_cv__MatxT_float_4_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_float_4_1_eye(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
SwigValueWrapper< cv::Matx< float,4,1 > > result;
if (!PyArg_ParseTuple(args,(char *)":_Matx_float_4_1_eye")) SWIG_fail;
result = cv::Matx< float,4,1 >::SWIGTEMPLATEDISAMBIGUATOR eye();
resultobj = SWIG_NewPointerObj((new cv::Matx< float,4,1 >(static_cast< const cv::Matx< float,4,1 >& >(result))), SWIGTYPE_p_cv__MatxT_float_4_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_float_4_1_randu(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 ;
SwigValueWrapper< cv::Matx< float,4,1 > > result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_float_4_1_randu",&obj0,&obj1)) SWIG_fail;
ecode1 = SWIG_AsVal_float(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_Matx_float_4_1_randu" "', 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 '" "_Matx_float_4_1_randu" "', argument " "2"" of type '" "float""'");
}
arg2 = static_cast< float >(val2);
result = cv::Matx< float,4,1 >::SWIGTEMPLATEDISAMBIGUATOR randu(arg1,arg2);
resultobj = SWIG_NewPointerObj((new cv::Matx< float,4,1 >(static_cast< const cv::Matx< float,4,1 >& >(result))), SWIGTYPE_p_cv__MatxT_float_4_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_float_4_1_randn(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 ;
SwigValueWrapper< cv::Matx< float,4,1 > > result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_float_4_1_randn",&obj0,&obj1)) SWIG_fail;
ecode1 = SWIG_AsVal_float(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_Matx_float_4_1_randn" "', 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 '" "_Matx_float_4_1_randn" "', argument " "2"" of type '" "float""'");
}
arg2 = static_cast< float >(val2);
result = cv::Matx< float,4,1 >::SWIGTEMPLATEDISAMBIGUATOR randn(arg1,arg2);
resultobj = SWIG_NewPointerObj((new cv::Matx< float,4,1 >(static_cast< const cv::Matx< float,4,1 >& >(result))), SWIGTYPE_p_cv__MatxT_float_4_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_float_4_1_dot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< float,4,1 > *arg1 = (cv::Matx< float,4,1 > *) 0 ;
cv::Matx< float,4,1 > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
float result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_float_4_1_dot",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_float_4_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_float_4_1_dot" "', argument " "1"" of type '" "cv::Matx< float,4,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< float,4,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_float_4_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_float_4_1_dot" "', argument " "2"" of type '" "cv::Matx< float,4,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Matx_float_4_1_dot" "', argument " "2"" of type '" "cv::Matx< float,4,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< float,4,1 > * >(argp2);
result = (float)((cv::Matx< float,4,1 > const *)arg1)->dot((cv::Matx< float,4,1 > const &)*arg2);
resultobj = SWIG_From_float(static_cast< float >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_float_4_1_ddot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< float,4,1 > *arg1 = (cv::Matx< float,4,1 > *) 0 ;
cv::Matx< float,4,1 > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
double result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_float_4_1_ddot",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_float_4_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_float_4_1_ddot" "', argument " "1"" of type '" "cv::Matx< float,4,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< float,4,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_float_4_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_float_4_1_ddot" "', argument " "2"" of type '" "cv::Matx< float,4,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Matx_float_4_1_ddot" "', argument " "2"" of type '" "cv::Matx< float,4,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< float,4,1 > * >(argp2);
result = (double)((cv::Matx< float,4,1 > const *)arg1)->ddot((cv::Matx< float,4,1 > const &)*arg2);
resultobj = SWIG_From_double(static_cast< double >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_float_4_1_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< float,4,1 > *arg1 = (cv::Matx< float,4,1 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
SwigValueWrapper< cv::Matx< float,1,4 > > result;
if (!PyArg_ParseTuple(args,(char *)"O:_Matx_float_4_1_t",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_float_4_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_float_4_1_t" "', argument " "1"" of type '" "cv::Matx< float,4,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< float,4,1 > * >(argp1);
result = ((cv::Matx< float,4,1 > const *)arg1)->t();
resultobj = SWIG_NewPointerObj((new cv::Matx< float,1,4 >(static_cast< const cv::Matx< float,1,4 >& >(result))), SWIGTYPE_p_cv__MatxT_float_1_4_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_float_4_1_mul(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< float,4,1 > *arg1 = (cv::Matx< float,4,1 > *) 0 ;
cv::Matx< float,4,1 > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
SwigValueWrapper< cv::Matx< float,4,1 > > result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_float_4_1_mul",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_float_4_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_float_4_1_mul" "', argument " "1"" of type '" "cv::Matx< float,4,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< float,4,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_float_4_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_float_4_1_mul" "', argument " "2"" of type '" "cv::Matx< float,4,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Matx_float_4_1_mul" "', argument " "2"" of type '" "cv::Matx< float,4,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< float,4,1 > * >(argp2);
result = ((cv::Matx< float,4,1 > const *)arg1)->mul((cv::Matx< float,4,1 > const &)*arg2);
resultobj = SWIG_NewPointerObj((new cv::Matx< float,4,1 >(static_cast< const cv::Matx< float,4,1 >& >(result))), SWIGTYPE_p_cv__MatxT_float_4_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_float_4_1_div(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< float,4,1 > *arg1 = (cv::Matx< float,4,1 > *) 0 ;
cv::Matx< float,4,1 > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
SwigValueWrapper< cv::Matx< float,4,1 > > result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_float_4_1_div",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_float_4_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_float_4_1_div" "', argument " "1"" of type '" "cv::Matx< float,4,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< float,4,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_float_4_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_float_4_1_div" "', argument " "2"" of type '" "cv::Matx< float,4,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Matx_float_4_1_div" "', argument " "2"" of type '" "cv::Matx< float,4,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< float,4,1 > * >(argp2);
result = ((cv::Matx< float,4,1 > const *)arg1)->div((cv::Matx< float,4,1 > const &)*arg2);
resultobj = SWIG_NewPointerObj((new cv::Matx< float,4,1 >(static_cast< const cv::Matx< float,4,1 >& >(result))), SWIGTYPE_p_cv__MatxT_float_4_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_float_4_1___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< float,4,1 > *arg1 = (cv::Matx< float,4,1 > *) 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 ;
float *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:_Matx_float_4_1___call__",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_float_4_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_float_4_1___call__" "', argument " "1"" of type '" "cv::Matx< float,4,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< float,4,1 > * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_Matx_float_4_1___call__" "', 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 '" "_Matx_float_4_1___call__" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
result = (float *) &((cv::Matx< float,4,1 > const *)arg1)->operator ()(arg2,arg3);
resultobj = SWIG_From_float(static_cast< float >(*result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_float_4_1__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< float,4,1 > *arg1 = 0 ;
cv::Matx< float,4,1 > *arg2 = 0 ;
cv::Matx_AddOp 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 ;
cv::Matx< float,4,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Matx_float_4_1",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_float_4_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_float_4_1" "', argument " "1"" of type '" "cv::Matx< float,4,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_float_4_1" "', argument " "1"" of type '" "cv::Matx< float,4,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< float,4,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_float_4_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Matx_float_4_1" "', argument " "2"" of type '" "cv::Matx< float,4,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_float_4_1" "', argument " "2"" of type '" "cv::Matx< float,4,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< float,4,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_AddOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Matx_float_4_1" "', argument " "3"" of type '" "cv::Matx_AddOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_float_4_1" "', argument " "3"" of type '" "cv::Matx_AddOp""'");
} else {
cv::Matx_AddOp * temp = reinterpret_cast< cv::Matx_AddOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Matx< float,4,1 > *)new cv::Matx< float,4,1 >((cv::Matx< float,4,1 > const &)*arg1,(cv::Matx< float,4,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_float_4_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_float_4_1__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< float,4,1 > *arg1 = 0 ;
cv::Matx< float,4,1 > *arg2 = 0 ;
cv::Matx_SubOp 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 ;
cv::Matx< float,4,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Matx_float_4_1",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_float_4_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_float_4_1" "', argument " "1"" of type '" "cv::Matx< float,4,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_float_4_1" "', argument " "1"" of type '" "cv::Matx< float,4,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< float,4,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_float_4_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Matx_float_4_1" "', argument " "2"" of type '" "cv::Matx< float,4,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_float_4_1" "', argument " "2"" of type '" "cv::Matx< float,4,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< float,4,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_SubOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Matx_float_4_1" "', argument " "3"" of type '" "cv::Matx_SubOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_float_4_1" "', argument " "3"" of type '" "cv::Matx_SubOp""'");
} else {
cv::Matx_SubOp * temp = reinterpret_cast< cv::Matx_SubOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Matx< float,4,1 > *)new cv::Matx< float,4,1 >((cv::Matx< float,4,1 > const &)*arg1,(cv::Matx< float,4,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_float_4_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_float_4_1__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< float,4,1 > *arg1 = 0 ;
cv::Matx< float,4,1 > *arg2 = 0 ;
cv::Matx_MulOp 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 ;
cv::Matx< float,4,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Matx_float_4_1",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_float_4_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_float_4_1" "', argument " "1"" of type '" "cv::Matx< float,4,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_float_4_1" "', argument " "1"" of type '" "cv::Matx< float,4,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< float,4,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_float_4_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Matx_float_4_1" "', argument " "2"" of type '" "cv::Matx< float,4,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_float_4_1" "', argument " "2"" of type '" "cv::Matx< float,4,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< float,4,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_MulOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Matx_float_4_1" "', argument " "3"" of type '" "cv::Matx_MulOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_float_4_1" "', argument " "3"" of type '" "cv::Matx_MulOp""'");
} else {
cv::Matx_MulOp * temp = reinterpret_cast< cv::Matx_MulOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Matx< float,4,1 > *)new cv::Matx< float,4,1 >((cv::Matx< float,4,1 > const &)*arg1,(cv::Matx< float,4,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_float_4_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_float_4_1__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< float,4,1 > *arg1 = 0 ;
cv::Matx< float,4,1 > *arg2 = 0 ;
cv::Matx_DivOp 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 ;
cv::Matx< float,4,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Matx_float_4_1",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_float_4_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_float_4_1" "', argument " "1"" of type '" "cv::Matx< float,4,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_float_4_1" "', argument " "1"" of type '" "cv::Matx< float,4,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< float,4,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_float_4_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Matx_float_4_1" "', argument " "2"" of type '" "cv::Matx< float,4,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_float_4_1" "', argument " "2"" of type '" "cv::Matx< float,4,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< float,4,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_DivOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Matx_float_4_1" "', argument " "3"" of type '" "cv::Matx_DivOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_float_4_1" "', argument " "3"" of type '" "cv::Matx_DivOp""'");
} else {
cv::Matx_DivOp * temp = reinterpret_cast< cv::Matx_DivOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Matx< float,4,1 > *)new cv::Matx< float,4,1 >((cv::Matx< float,4,1 > const &)*arg1,(cv::Matx< float,4,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_float_4_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_float_4_1__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< float,1,4 > *arg1 = 0 ;
cv::Matx_TOp arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
cv::Matx< float,4,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:new__Matx_float_4_1",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_float_1_4_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_float_4_1" "', argument " "1"" of type '" "cv::Matx< float,1,4 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_float_4_1" "', argument " "1"" of type '" "cv::Matx< float,1,4 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< float,1,4 > * >(argp1);
{
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__Matx_TOp, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Matx_float_4_1" "', argument " "2"" of type '" "cv::Matx_TOp""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_float_4_1" "', argument " "2"" of type '" "cv::Matx_TOp""'");
} else {
cv::Matx_TOp * temp = reinterpret_cast< cv::Matx_TOp * >(argp2);
arg2 = *temp;
if (SWIG_IsNewObj(res2)) delete temp;
}
}
result = (cv::Matx< float,4,1 > *)new cv::Matx< float,4,1 >((cv::Matx< float,1,4 > const &)*arg1,arg2);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_float_4_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_float_4_1_val_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< float,4,1 > *arg1 = (cv::Matx< float,4,1 > *) 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:_Matx_float_4_1_val_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_float_4_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_float_4_1_val_set" "', argument " "1"" of type '" "cv::Matx< float,4,1 > *""'");
}
arg1 = reinterpret_cast< cv::Matx< float,4,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_float, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_float_4_1_val_set" "', argument " "2"" of type '" "float [4*1]""'");
}
arg2 = reinterpret_cast< float * >(argp2);
{
if (arg2) {
size_t ii = 0;
for (; ii < (size_t)4*1; ++ii) *(float *)&arg1->val[ii] = *((float *)arg2 + ii);
} else {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""val""' of type '""float [4*1]""'");
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_float_4_1_val_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< float,4,1 > *arg1 = (cv::Matx< float,4,1 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
float *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:_Matx_float_4_1_val_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_float_4_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_float_4_1_val_get" "', argument " "1"" of type '" "cv::Matx< float,4,1 > *""'");
}
arg1 = reinterpret_cast< cv::Matx< float,4,1 > * >(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_new__Matx_float_4_1__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< cv::Matx< float,4,1 >::value_type,std::allocator< cv::Matx< float,4,1 >::value_type > > arg1 ;
PyObject * obj0 = 0 ;
cv::Matx< float,4,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__Matx_float_4_1",&obj0)) SWIG_fail;
{
std::vector< float,std::allocator< float > > *ptr = (std::vector< float,std::allocator< float > > *)0;
int res = swig::asptr(obj0, &ptr);
if (!SWIG_IsOK(res) || !ptr) {
SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new__Matx_float_4_1" "', argument " "1"" of type '" "std::vector< cv::Matx< float,4,1 >::value_type,std::allocator< cv::Matx< float,4,1 >::value_type > >""'");
}
arg1 = *ptr;
if (SWIG_IsNewObj(res)) delete ptr;
}
result = (cv::Matx< float,4,1 > *)new_cv_Matx_Sl_float_Sc_4_Sc_1_Sg___SWIG_6(arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_float_4_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_float_4_1(PyObject *self, PyObject *args) {
Py_ssize_t argc;
PyObject *argv[4] = {
0
};
Py_ssize_t ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = args ? PyObject_Length(args) : 0;
for (ii = 0; (ii < 3) && (ii < argc); 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_float, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_float_4_1__SWIG_0(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__Matx_float_4_1__SWIG_6(self, args);
}
}
if (argc == 2) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_float_1_4_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__Matx_TOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_float_4_1__SWIG_5(self, args);
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_float_4_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_float_4_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_MulOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_float_4_1__SWIG_3(self, args);
}
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_float_4_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_float_4_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_DivOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_float_4_1__SWIG_4(self, args);
}
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_float_4_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_float_4_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_AddOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_float_4_1__SWIG_1(self, args);
}
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_float_4_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_float_4_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_SubOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_float_4_1__SWIG_2(self, args);
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new__Matx_float_4_1'.\n"
" Possible C/C++ prototypes are:\n"
" cv::Matx< float,4,1 >::Matx(float const *)\n"
" cv::Matx< float,4,1 >::Matx(cv::Matx< float,4,1 > const &,cv::Matx< float,4,1 > const &,cv::Matx_AddOp)\n"
" cv::Matx< float,4,1 >::Matx(cv::Matx< float,4,1 > const &,cv::Matx< float,4,1 > const &,cv::Matx_SubOp)\n"
" cv::Matx< float,4,1 >::Matx(cv::Matx< float,4,1 > const &,cv::Matx< float,4,1 > const &,cv::Matx_MulOp)\n"
" cv::Matx< float,4,1 >::Matx(cv::Matx< float,4,1 > const &,cv::Matx< float,4,1 > const &,cv::Matx_DivOp)\n"
" cv::Matx< float,4,1 >::Matx(cv::Matx< float,1,4 > const &,cv::Matx_TOp)\n"
" cv::Matx< float,4,1 >::Matx(std::vector< cv::Matx< float,4,1 >::value_type,std::allocator< cv::Matx< float,4,1 >::value_type > >)\n");
return 0;
}
SWIGINTERN PyObject *_wrap__Matx_float_4_1___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< float,4,1 > *arg1 = (cv::Matx< float,4,1 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
std::string result;
if (!PyArg_ParseTuple(args,(char *)"O:_Matx_float_4_1___str__",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_float_4_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_float_4_1___str__" "', argument " "1"" of type '" "cv::Matx< float,4,1 > *""'");
}
arg1 = reinterpret_cast< cv::Matx< float,4,1 > * >(argp1);
result = cv_Matx_Sl_float_Sc_4_Sc_1_Sg____str__(arg1);
resultobj = SWIG_From_std_string(static_cast< std::string >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete__Matx_float_4_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< float,4,1 > *arg1 = (cv::Matx< float,4,1 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete__Matx_float_4_1",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_float_4_1_t, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__Matx_float_4_1" "', argument " "1"" of type '" "cv::Matx< float,4,1 > *""'");
}
arg1 = reinterpret_cast< cv::Matx< float,4,1 > * >(argp1);
delete arg1;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_Matx_float_4_1_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_cv__MatxT_float_4_1_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_new__Vec_float_4__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
float *arg1 = (float *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
cv::Vec< float,4 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__Vec_float_4",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_float, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Vec_float_4" "', argument " "1"" of type '" "float const *""'");
}
arg1 = reinterpret_cast< float * >(argp1);
result = (cv::Vec< float,4 > *)new cv::Vec< float,4 >((float const *)arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__VecT_float_4_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Vec_float_4__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Vec< float,4 > *arg1 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
cv::Vec< float,4 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__Vec_float_4",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__VecT_float_4_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Vec_float_4" "', argument " "1"" of type '" "cv::Vec< float,4 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_float_4" "', argument " "1"" of type '" "cv::Vec< float,4 > const &""'");
}
arg1 = reinterpret_cast< cv::Vec< float,4 > * >(argp1);
result = (cv::Vec< float,4 > *)new cv::Vec< float,4 >((cv::Vec< float,4 > const &)*arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__VecT_float_4_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Vec_float_4_all(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
float arg1 ;
float val1 ;
int ecode1 = 0 ;
PyObject * obj0 = 0 ;
SwigValueWrapper< cv::Vec< float,4 > > result;
if (!PyArg_ParseTuple(args,(char *)"O:_Vec_float_4_all",&obj0)) SWIG_fail;
ecode1 = SWIG_AsVal_float(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_Vec_float_4_all" "', argument " "1"" of type '" "float""'");
}
arg1 = static_cast< float >(val1);
result = cv::Vec< float,4 >::SWIGTEMPLATEDISAMBIGUATOR all(arg1);
resultobj = SWIG_NewPointerObj((new cv::Vec< float,4 >(static_cast< const cv::Vec< float,4 >& >(result))), SWIGTYPE_p_cv__VecT_float_4_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Vec_float_4_mul(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Vec< float,4 > *arg1 = (cv::Vec< float,4 > *) 0 ;
cv::Vec< float,4 > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
SwigValueWrapper< cv::Vec< float,4 > > result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Vec_float_4_mul",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__VecT_float_4_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Vec_float_4_mul" "', argument " "1"" of type '" "cv::Vec< float,4 > const *""'");
}
arg1 = reinterpret_cast< cv::Vec< float,4 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__VecT_float_4_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Vec_float_4_mul" "', argument " "2"" of type '" "cv::Vec< float,4 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Vec_float_4_mul" "', argument " "2"" of type '" "cv::Vec< float,4 > const &""'");
}
arg2 = reinterpret_cast< cv::Vec< float,4 > * >(argp2);
result = ((cv::Vec< float,4 > const *)arg1)->mul((cv::Vec< float,4 > const &)*arg2);
resultobj = SWIG_NewPointerObj((new cv::Vec< float,4 >(static_cast< const cv::Vec< float,4 >& >(result))), SWIGTYPE_p_cv__VecT_float_4_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Vec_float_4___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Vec< float,4 > *arg1 = (cv::Vec< float,4 > *) 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:_Vec_float_4___call__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__VecT_float_4_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Vec_float_4___call__" "', argument " "1"" of type '" "cv::Vec< float,4 > const *""'");
}
arg1 = reinterpret_cast< cv::Vec< float,4 > * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_Vec_float_4___call__" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
result = (float *) &((cv::Vec< float,4 > const *)arg1)->operator ()(arg2);
resultobj = SWIG_From_float(static_cast< float >(*result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Vec_float_4__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< float,4,1 > *arg1 = 0 ;
cv::Matx< float,4,1 > *arg2 = 0 ;
cv::Matx_AddOp 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 ;
cv::Vec< float,4 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Vec_float_4",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_float_4_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Vec_float_4" "', argument " "1"" of type '" "cv::Matx< float,4,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_float_4" "', argument " "1"" of type '" "cv::Matx< float,4,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< float,4,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_float_4_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Vec_float_4" "', argument " "2"" of type '" "cv::Matx< float,4,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_float_4" "', argument " "2"" of type '" "cv::Matx< float,4,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< float,4,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_AddOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Vec_float_4" "', argument " "3"" of type '" "cv::Matx_AddOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_float_4" "', argument " "3"" of type '" "cv::Matx_AddOp""'");
} else {
cv::Matx_AddOp * temp = reinterpret_cast< cv::Matx_AddOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Vec< float,4 > *)new cv::Vec< float,4 >((cv::Matx< float,4,1 > const &)*arg1,(cv::Matx< float,4,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__VecT_float_4_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Vec_float_4__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< float,4,1 > *arg1 = 0 ;
cv::Matx< float,4,1 > *arg2 = 0 ;
cv::Matx_SubOp 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 ;
cv::Vec< float,4 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Vec_float_4",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_float_4_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Vec_float_4" "', argument " "1"" of type '" "cv::Matx< float,4,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_float_4" "', argument " "1"" of type '" "cv::Matx< float,4,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< float,4,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_float_4_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Vec_float_4" "', argument " "2"" of type '" "cv::Matx< float,4,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_float_4" "', argument " "2"" of type '" "cv::Matx< float,4,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< float,4,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_SubOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Vec_float_4" "', argument " "3"" of type '" "cv::Matx_SubOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_float_4" "', argument " "3"" of type '" "cv::Matx_SubOp""'");
} else {
cv::Matx_SubOp * temp = reinterpret_cast< cv::Matx_SubOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Vec< float,4 > *)new cv::Vec< float,4 >((cv::Matx< float,4,1 > const &)*arg1,(cv::Matx< float,4,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__VecT_float_4_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Vec_float_4__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< cv::Vec< float,4 >::value_type,std::allocator< cv::Vec< float,4 >::value_type > > arg1 ;
PyObject * obj0 = 0 ;
cv::Vec< float,4 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__Vec_float_4",&obj0)) SWIG_fail;
{
std::vector< float,std::allocator< float > > *ptr = (std::vector< float,std::allocator< float > > *)0;
int res = swig::asptr(obj0, &ptr);
if (!SWIG_IsOK(res) || !ptr) {
SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new__Vec_float_4" "', argument " "1"" of type '" "std::vector< cv::Vec< float,4 >::value_type,std::allocator< cv::Vec< float,4 >::value_type > >""'");
}
arg1 = *ptr;
if (SWIG_IsNewObj(res)) delete ptr;
}
result = (cv::Vec< float,4 > *)new_cv_Vec_Sl_float_Sc_4_Sg___SWIG_4(arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__VecT_float_4_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Vec_float_4(PyObject *self, PyObject *args) {
Py_ssize_t argc;
PyObject *argv[4] = {
0
};
Py_ssize_t ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = args ? PyObject_Length(args) : 0;
for (ii = 0; (ii < 3) && (ii < argc); 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_float, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Vec_float_4__SWIG_0(self, args);
}
}
if (argc == 1) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__VecT_float_4_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Vec_float_4__SWIG_1(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__Vec_float_4__SWIG_4(self, args);
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_float_4_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_float_4_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_SubOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Vec_float_4__SWIG_3(self, args);
}
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_float_4_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_float_4_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_AddOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Vec_float_4__SWIG_2(self, args);
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new__Vec_float_4'.\n"
" Possible C/C++ prototypes are:\n"
" cv::Vec< float,4 >::Vec(float const *)\n"
" cv::Vec< float,4 >::Vec(cv::Vec< float,4 > const &)\n"
" cv::Vec< float,4 >::Vec(cv::Matx< float,4,1 > const &,cv::Matx< float,4,1 > const &,cv::Matx_AddOp)\n"
" cv::Vec< float,4 >::Vec(cv::Matx< float,4,1 > const &,cv::Matx< float,4,1 > const &,cv::Matx_SubOp)\n"
" cv::Vec< float,4 >::Vec(std::vector< cv::Vec< float,4 >::value_type,std::allocator< cv::Vec< float,4 >::value_type > >)\n");
return 0;
}
SWIGINTERN PyObject *_wrap__Vec_float_4___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Vec< float,4 > *arg1 = (cv::Vec< float,4 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
std::string result;
if (!PyArg_ParseTuple(args,(char *)"O:_Vec_float_4___str__",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__VecT_float_4_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Vec_float_4___str__" "', argument " "1"" of type '" "cv::Vec< float,4 > *""'");
}
arg1 = reinterpret_cast< cv::Vec< float,4 > * >(argp1);
result = cv_Vec_Sl_float_Sc_4_Sg____str__(arg1);
resultobj = SWIG_From_std_string(static_cast< std::string >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete__Vec_float_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Vec< float,4 > *arg1 = (cv::Vec< float,4 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete__Vec_float_4",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__VecT_float_4_t, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__Vec_float_4" "', argument " "1"" of type '" "cv::Vec< float,4 > *""'");
}
arg1 = reinterpret_cast< cv::Vec< float,4 > * >(argp1);
delete arg1;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_Vec_float_4_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_cv__VecT_float_4_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_new__DataType_Vec_float_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::DataType< cv::Vec< float,4 > > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new__DataType_Vec_float_4")) SWIG_fail;
result = (cv::DataType< cv::Vec< float,4 > > *)new cv::DataType< cv::Vec< float,4 > >();
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__DataTypeT_cv__VecT_float_4_t_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete__DataType_Vec_float_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::DataType< cv::Vec< float,4 > > *arg1 = (cv::DataType< cv::Vec< float,4 > > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete__DataType_Vec_float_4",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__DataTypeT_cv__VecT_float_4_t_t, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__DataType_Vec_float_4" "', argument " "1"" of type '" "cv::DataType< cv::Vec< float,4 > > *""'");
}
arg1 = reinterpret_cast< cv::DataType< cv::Vec< float,4 > > * >(argp1);
delete arg1;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_DataType_Vec_float_4_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_cv__DataTypeT_cv__VecT_float_4_t_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_new__Matx_float_6_1__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
float *arg1 = (float *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
cv::Matx< float,6,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__Matx_float_6_1",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_float, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_float_6_1" "', argument " "1"" of type '" "float const *""'");
}
arg1 = reinterpret_cast< float * >(argp1);
result = (cv::Matx< float,6,1 > *)new cv::Matx< float,6,1 >((float const *)arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_float_6_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_float_6_1_all(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
float arg1 ;
float val1 ;
int ecode1 = 0 ;
PyObject * obj0 = 0 ;
SwigValueWrapper< cv::Matx< float,6,1 > > result;
if (!PyArg_ParseTuple(args,(char *)"O:_Matx_float_6_1_all",&obj0)) SWIG_fail;
ecode1 = SWIG_AsVal_float(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_Matx_float_6_1_all" "', argument " "1"" of type '" "float""'");
}
arg1 = static_cast< float >(val1);
result = cv::Matx< float,6,1 >::SWIGTEMPLATEDISAMBIGUATOR all(arg1);
resultobj = SWIG_NewPointerObj((new cv::Matx< float,6,1 >(static_cast< const cv::Matx< float,6,1 >& >(result))), SWIGTYPE_p_cv__MatxT_float_6_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_float_6_1_zeros(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
SwigValueWrapper< cv::Matx< float,6,1 > > result;
if (!PyArg_ParseTuple(args,(char *)":_Matx_float_6_1_zeros")) SWIG_fail;
result = cv::Matx< float,6,1 >::SWIGTEMPLATEDISAMBIGUATOR zeros();
resultobj = SWIG_NewPointerObj((new cv::Matx< float,6,1 >(static_cast< const cv::Matx< float,6,1 >& >(result))), SWIGTYPE_p_cv__MatxT_float_6_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_float_6_1_ones(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
SwigValueWrapper< cv::Matx< float,6,1 > > result;
if (!PyArg_ParseTuple(args,(char *)":_Matx_float_6_1_ones")) SWIG_fail;
result = cv::Matx< float,6,1 >::SWIGTEMPLATEDISAMBIGUATOR ones();
resultobj = SWIG_NewPointerObj((new cv::Matx< float,6,1 >(static_cast< const cv::Matx< float,6,1 >& >(result))), SWIGTYPE_p_cv__MatxT_float_6_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_float_6_1_eye(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
SwigValueWrapper< cv::Matx< float,6,1 > > result;
if (!PyArg_ParseTuple(args,(char *)":_Matx_float_6_1_eye")) SWIG_fail;
result = cv::Matx< float,6,1 >::SWIGTEMPLATEDISAMBIGUATOR eye();
resultobj = SWIG_NewPointerObj((new cv::Matx< float,6,1 >(static_cast< const cv::Matx< float,6,1 >& >(result))), SWIGTYPE_p_cv__MatxT_float_6_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_float_6_1_randu(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 ;
SwigValueWrapper< cv::Matx< float,6,1 > > result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_float_6_1_randu",&obj0,&obj1)) SWIG_fail;
ecode1 = SWIG_AsVal_float(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_Matx_float_6_1_randu" "', 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 '" "_Matx_float_6_1_randu" "', argument " "2"" of type '" "float""'");
}
arg2 = static_cast< float >(val2);
result = cv::Matx< float,6,1 >::SWIGTEMPLATEDISAMBIGUATOR randu(arg1,arg2);
resultobj = SWIG_NewPointerObj((new cv::Matx< float,6,1 >(static_cast< const cv::Matx< float,6,1 >& >(result))), SWIGTYPE_p_cv__MatxT_float_6_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_float_6_1_randn(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 ;
SwigValueWrapper< cv::Matx< float,6,1 > > result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_float_6_1_randn",&obj0,&obj1)) SWIG_fail;
ecode1 = SWIG_AsVal_float(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_Matx_float_6_1_randn" "', 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 '" "_Matx_float_6_1_randn" "', argument " "2"" of type '" "float""'");
}
arg2 = static_cast< float >(val2);
result = cv::Matx< float,6,1 >::SWIGTEMPLATEDISAMBIGUATOR randn(arg1,arg2);
resultobj = SWIG_NewPointerObj((new cv::Matx< float,6,1 >(static_cast< const cv::Matx< float,6,1 >& >(result))), SWIGTYPE_p_cv__MatxT_float_6_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_float_6_1_dot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< float,6,1 > *arg1 = (cv::Matx< float,6,1 > *) 0 ;
cv::Matx< float,6,1 > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
float result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_float_6_1_dot",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_float_6_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_float_6_1_dot" "', argument " "1"" of type '" "cv::Matx< float,6,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< float,6,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_float_6_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_float_6_1_dot" "', argument " "2"" of type '" "cv::Matx< float,6,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Matx_float_6_1_dot" "', argument " "2"" of type '" "cv::Matx< float,6,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< float,6,1 > * >(argp2);
result = (float)((cv::Matx< float,6,1 > const *)arg1)->dot((cv::Matx< float,6,1 > const &)*arg2);
resultobj = SWIG_From_float(static_cast< float >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_float_6_1_ddot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< float,6,1 > *arg1 = (cv::Matx< float,6,1 > *) 0 ;
cv::Matx< float,6,1 > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
double result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_float_6_1_ddot",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_float_6_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_float_6_1_ddot" "', argument " "1"" of type '" "cv::Matx< float,6,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< float,6,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_float_6_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_float_6_1_ddot" "', argument " "2"" of type '" "cv::Matx< float,6,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Matx_float_6_1_ddot" "', argument " "2"" of type '" "cv::Matx< float,6,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< float,6,1 > * >(argp2);
result = (double)((cv::Matx< float,6,1 > const *)arg1)->ddot((cv::Matx< float,6,1 > const &)*arg2);
resultobj = SWIG_From_double(static_cast< double >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_float_6_1_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< float,6,1 > *arg1 = (cv::Matx< float,6,1 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
SwigValueWrapper< cv::Matx< float,1,6 > > result;
if (!PyArg_ParseTuple(args,(char *)"O:_Matx_float_6_1_t",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_float_6_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_float_6_1_t" "', argument " "1"" of type '" "cv::Matx< float,6,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< float,6,1 > * >(argp1);
result = ((cv::Matx< float,6,1 > const *)arg1)->t();
resultobj = SWIG_NewPointerObj((new cv::Matx< float,1,6 >(static_cast< const cv::Matx< float,1,6 >& >(result))), SWIGTYPE_p_cv__MatxT_float_1_6_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_float_6_1_mul(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< float,6,1 > *arg1 = (cv::Matx< float,6,1 > *) 0 ;
cv::Matx< float,6,1 > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
SwigValueWrapper< cv::Matx< float,6,1 > > result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_float_6_1_mul",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_float_6_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_float_6_1_mul" "', argument " "1"" of type '" "cv::Matx< float,6,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< float,6,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_float_6_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_float_6_1_mul" "', argument " "2"" of type '" "cv::Matx< float,6,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Matx_float_6_1_mul" "', argument " "2"" of type '" "cv::Matx< float,6,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< float,6,1 > * >(argp2);
result = ((cv::Matx< float,6,1 > const *)arg1)->mul((cv::Matx< float,6,1 > const &)*arg2);
resultobj = SWIG_NewPointerObj((new cv::Matx< float,6,1 >(static_cast< const cv::Matx< float,6,1 >& >(result))), SWIGTYPE_p_cv__MatxT_float_6_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_float_6_1_div(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< float,6,1 > *arg1 = (cv::Matx< float,6,1 > *) 0 ;
cv::Matx< float,6,1 > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
SwigValueWrapper< cv::Matx< float,6,1 > > result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_float_6_1_div",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_float_6_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_float_6_1_div" "', argument " "1"" of type '" "cv::Matx< float,6,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< float,6,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_float_6_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_float_6_1_div" "', argument " "2"" of type '" "cv::Matx< float,6,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Matx_float_6_1_div" "', argument " "2"" of type '" "cv::Matx< float,6,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< float,6,1 > * >(argp2);
result = ((cv::Matx< float,6,1 > const *)arg1)->div((cv::Matx< float,6,1 > const &)*arg2);
resultobj = SWIG_NewPointerObj((new cv::Matx< float,6,1 >(static_cast< const cv::Matx< float,6,1 >& >(result))), SWIGTYPE_p_cv__MatxT_float_6_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_float_6_1___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< float,6,1 > *arg1 = (cv::Matx< float,6,1 > *) 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 ;
float *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:_Matx_float_6_1___call__",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_float_6_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_float_6_1___call__" "', argument " "1"" of type '" "cv::Matx< float,6,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< float,6,1 > * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_Matx_float_6_1___call__" "', 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 '" "_Matx_float_6_1___call__" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
result = (float *) &((cv::Matx< float,6,1 > const *)arg1)->operator ()(arg2,arg3);
resultobj = SWIG_From_float(static_cast< float >(*result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_float_6_1__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< float,6,1 > *arg1 = 0 ;
cv::Matx< float,6,1 > *arg2 = 0 ;
cv::Matx_AddOp 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 ;
cv::Matx< float,6,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Matx_float_6_1",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_float_6_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_float_6_1" "', argument " "1"" of type '" "cv::Matx< float,6,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_float_6_1" "', argument " "1"" of type '" "cv::Matx< float,6,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< float,6,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_float_6_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Matx_float_6_1" "', argument " "2"" of type '" "cv::Matx< float,6,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_float_6_1" "', argument " "2"" of type '" "cv::Matx< float,6,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< float,6,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_AddOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Matx_float_6_1" "', argument " "3"" of type '" "cv::Matx_AddOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_float_6_1" "', argument " "3"" of type '" "cv::Matx_AddOp""'");
} else {
cv::Matx_AddOp * temp = reinterpret_cast< cv::Matx_AddOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Matx< float,6,1 > *)new cv::Matx< float,6,1 >((cv::Matx< float,6,1 > const &)*arg1,(cv::Matx< float,6,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_float_6_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_float_6_1__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< float,6,1 > *arg1 = 0 ;
cv::Matx< float,6,1 > *arg2 = 0 ;
cv::Matx_SubOp 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 ;
cv::Matx< float,6,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Matx_float_6_1",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_float_6_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_float_6_1" "', argument " "1"" of type '" "cv::Matx< float,6,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_float_6_1" "', argument " "1"" of type '" "cv::Matx< float,6,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< float,6,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_float_6_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Matx_float_6_1" "', argument " "2"" of type '" "cv::Matx< float,6,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_float_6_1" "', argument " "2"" of type '" "cv::Matx< float,6,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< float,6,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_SubOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Matx_float_6_1" "', argument " "3"" of type '" "cv::Matx_SubOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_float_6_1" "', argument " "3"" of type '" "cv::Matx_SubOp""'");
} else {
cv::Matx_SubOp * temp = reinterpret_cast< cv::Matx_SubOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Matx< float,6,1 > *)new cv::Matx< float,6,1 >((cv::Matx< float,6,1 > const &)*arg1,(cv::Matx< float,6,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_float_6_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_float_6_1__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< float,6,1 > *arg1 = 0 ;
cv::Matx< float,6,1 > *arg2 = 0 ;
cv::Matx_MulOp 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 ;
cv::Matx< float,6,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Matx_float_6_1",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_float_6_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_float_6_1" "', argument " "1"" of type '" "cv::Matx< float,6,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_float_6_1" "', argument " "1"" of type '" "cv::Matx< float,6,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< float,6,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_float_6_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Matx_float_6_1" "', argument " "2"" of type '" "cv::Matx< float,6,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_float_6_1" "', argument " "2"" of type '" "cv::Matx< float,6,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< float,6,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_MulOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Matx_float_6_1" "', argument " "3"" of type '" "cv::Matx_MulOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_float_6_1" "', argument " "3"" of type '" "cv::Matx_MulOp""'");
} else {
cv::Matx_MulOp * temp = reinterpret_cast< cv::Matx_MulOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Matx< float,6,1 > *)new cv::Matx< float,6,1 >((cv::Matx< float,6,1 > const &)*arg1,(cv::Matx< float,6,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_float_6_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_float_6_1__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< float,6,1 > *arg1 = 0 ;
cv::Matx< float,6,1 > *arg2 = 0 ;
cv::Matx_DivOp 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 ;
cv::Matx< float,6,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Matx_float_6_1",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_float_6_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_float_6_1" "', argument " "1"" of type '" "cv::Matx< float,6,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_float_6_1" "', argument " "1"" of type '" "cv::Matx< float,6,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< float,6,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_float_6_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Matx_float_6_1" "', argument " "2"" of type '" "cv::Matx< float,6,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_float_6_1" "', argument " "2"" of type '" "cv::Matx< float,6,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< float,6,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_DivOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Matx_float_6_1" "', argument " "3"" of type '" "cv::Matx_DivOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_float_6_1" "', argument " "3"" of type '" "cv::Matx_DivOp""'");
} else {
cv::Matx_DivOp * temp = reinterpret_cast< cv::Matx_DivOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Matx< float,6,1 > *)new cv::Matx< float,6,1 >((cv::Matx< float,6,1 > const &)*arg1,(cv::Matx< float,6,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_float_6_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_float_6_1__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< float,1,6 > *arg1 = 0 ;
cv::Matx_TOp arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
cv::Matx< float,6,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:new__Matx_float_6_1",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_float_1_6_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_float_6_1" "', argument " "1"" of type '" "cv::Matx< float,1,6 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_float_6_1" "', argument " "1"" of type '" "cv::Matx< float,1,6 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< float,1,6 > * >(argp1);
{
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__Matx_TOp, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Matx_float_6_1" "', argument " "2"" of type '" "cv::Matx_TOp""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_float_6_1" "', argument " "2"" of type '" "cv::Matx_TOp""'");
} else {
cv::Matx_TOp * temp = reinterpret_cast< cv::Matx_TOp * >(argp2);
arg2 = *temp;
if (SWIG_IsNewObj(res2)) delete temp;
}
}
result = (cv::Matx< float,6,1 > *)new cv::Matx< float,6,1 >((cv::Matx< float,1,6 > const &)*arg1,arg2);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_float_6_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_float_6_1_val_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< float,6,1 > *arg1 = (cv::Matx< float,6,1 > *) 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:_Matx_float_6_1_val_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_float_6_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_float_6_1_val_set" "', argument " "1"" of type '" "cv::Matx< float,6,1 > *""'");
}
arg1 = reinterpret_cast< cv::Matx< float,6,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_float, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_float_6_1_val_set" "', argument " "2"" of type '" "float [6*1]""'");
}
arg2 = reinterpret_cast< float * >(argp2);
{
if (arg2) {
size_t ii = 0;
for (; ii < (size_t)6*1; ++ii) *(float *)&arg1->val[ii] = *((float *)arg2 + ii);
} else {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""val""' of type '""float [6*1]""'");
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_float_6_1_val_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< float,6,1 > *arg1 = (cv::Matx< float,6,1 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
float *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:_Matx_float_6_1_val_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_float_6_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_float_6_1_val_get" "', argument " "1"" of type '" "cv::Matx< float,6,1 > *""'");
}
arg1 = reinterpret_cast< cv::Matx< float,6,1 > * >(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_new__Matx_float_6_1__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< cv::Matx< float,6,1 >::value_type,std::allocator< cv::Matx< float,6,1 >::value_type > > arg1 ;
PyObject * obj0 = 0 ;
cv::Matx< float,6,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__Matx_float_6_1",&obj0)) SWIG_fail;
{
std::vector< float,std::allocator< float > > *ptr = (std::vector< float,std::allocator< float > > *)0;
int res = swig::asptr(obj0, &ptr);
if (!SWIG_IsOK(res) || !ptr) {
SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new__Matx_float_6_1" "', argument " "1"" of type '" "std::vector< cv::Matx< float,6,1 >::value_type,std::allocator< cv::Matx< float,6,1 >::value_type > >""'");
}
arg1 = *ptr;
if (SWIG_IsNewObj(res)) delete ptr;
}
result = (cv::Matx< float,6,1 > *)new_cv_Matx_Sl_float_Sc_6_Sc_1_Sg___SWIG_6(arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_float_6_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_float_6_1(PyObject *self, PyObject *args) {
Py_ssize_t argc;
PyObject *argv[4] = {
0
};
Py_ssize_t ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = args ? PyObject_Length(args) : 0;
for (ii = 0; (ii < 3) && (ii < argc); 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_float, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_float_6_1__SWIG_0(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__Matx_float_6_1__SWIG_6(self, args);
}
}
if (argc == 2) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_float_1_6_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__Matx_TOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_float_6_1__SWIG_5(self, args);
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_float_6_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_float_6_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_MulOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_float_6_1__SWIG_3(self, args);
}
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_float_6_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_float_6_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_DivOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_float_6_1__SWIG_4(self, args);
}
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_float_6_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_float_6_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_AddOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_float_6_1__SWIG_1(self, args);
}
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_float_6_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_float_6_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_SubOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_float_6_1__SWIG_2(self, args);
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new__Matx_float_6_1'.\n"
" Possible C/C++ prototypes are:\n"
" cv::Matx< float,6,1 >::Matx(float const *)\n"
" cv::Matx< float,6,1 >::Matx(cv::Matx< float,6,1 > const &,cv::Matx< float,6,1 > const &,cv::Matx_AddOp)\n"
" cv::Matx< float,6,1 >::Matx(cv::Matx< float,6,1 > const &,cv::Matx< float,6,1 > const &,cv::Matx_SubOp)\n"
" cv::Matx< float,6,1 >::Matx(cv::Matx< float,6,1 > const &,cv::Matx< float,6,1 > const &,cv::Matx_MulOp)\n"
" cv::Matx< float,6,1 >::Matx(cv::Matx< float,6,1 > const &,cv::Matx< float,6,1 > const &,cv::Matx_DivOp)\n"
" cv::Matx< float,6,1 >::Matx(cv::Matx< float,1,6 > const &,cv::Matx_TOp)\n"
" cv::Matx< float,6,1 >::Matx(std::vector< cv::Matx< float,6,1 >::value_type,std::allocator< cv::Matx< float,6,1 >::value_type > >)\n");
return 0;
}
SWIGINTERN PyObject *_wrap__Matx_float_6_1___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< float,6,1 > *arg1 = (cv::Matx< float,6,1 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
std::string result;
if (!PyArg_ParseTuple(args,(char *)"O:_Matx_float_6_1___str__",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_float_6_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_float_6_1___str__" "', argument " "1"" of type '" "cv::Matx< float,6,1 > *""'");
}
arg1 = reinterpret_cast< cv::Matx< float,6,1 > * >(argp1);
result = cv_Matx_Sl_float_Sc_6_Sc_1_Sg____str__(arg1);
resultobj = SWIG_From_std_string(static_cast< std::string >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete__Matx_float_6_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< float,6,1 > *arg1 = (cv::Matx< float,6,1 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete__Matx_float_6_1",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_float_6_1_t, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__Matx_float_6_1" "', argument " "1"" of type '" "cv::Matx< float,6,1 > *""'");
}
arg1 = reinterpret_cast< cv::Matx< float,6,1 > * >(argp1);
delete arg1;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_Matx_float_6_1_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_cv__MatxT_float_6_1_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_new__Vec_float_6__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
float *arg1 = (float *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
cv::Vec< float,6 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__Vec_float_6",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_float, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Vec_float_6" "', argument " "1"" of type '" "float const *""'");
}
arg1 = reinterpret_cast< float * >(argp1);
result = (cv::Vec< float,6 > *)new cv::Vec< float,6 >((float const *)arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__VecT_float_6_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Vec_float_6__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Vec< float,6 > *arg1 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
cv::Vec< float,6 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__Vec_float_6",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__VecT_float_6_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Vec_float_6" "', argument " "1"" of type '" "cv::Vec< float,6 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_float_6" "', argument " "1"" of type '" "cv::Vec< float,6 > const &""'");
}
arg1 = reinterpret_cast< cv::Vec< float,6 > * >(argp1);
result = (cv::Vec< float,6 > *)new cv::Vec< float,6 >((cv::Vec< float,6 > const &)*arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__VecT_float_6_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Vec_float_6_all(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
float arg1 ;
float val1 ;
int ecode1 = 0 ;
PyObject * obj0 = 0 ;
SwigValueWrapper< cv::Vec< float,6 > > result;
if (!PyArg_ParseTuple(args,(char *)"O:_Vec_float_6_all",&obj0)) SWIG_fail;
ecode1 = SWIG_AsVal_float(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_Vec_float_6_all" "', argument " "1"" of type '" "float""'");
}
arg1 = static_cast< float >(val1);
result = cv::Vec< float,6 >::SWIGTEMPLATEDISAMBIGUATOR all(arg1);
resultobj = SWIG_NewPointerObj((new cv::Vec< float,6 >(static_cast< const cv::Vec< float,6 >& >(result))), SWIGTYPE_p_cv__VecT_float_6_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Vec_float_6_mul(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Vec< float,6 > *arg1 = (cv::Vec< float,6 > *) 0 ;
cv::Vec< float,6 > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
SwigValueWrapper< cv::Vec< float,6 > > result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Vec_float_6_mul",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__VecT_float_6_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Vec_float_6_mul" "', argument " "1"" of type '" "cv::Vec< float,6 > const *""'");
}
arg1 = reinterpret_cast< cv::Vec< float,6 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__VecT_float_6_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Vec_float_6_mul" "', argument " "2"" of type '" "cv::Vec< float,6 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Vec_float_6_mul" "', argument " "2"" of type '" "cv::Vec< float,6 > const &""'");
}
arg2 = reinterpret_cast< cv::Vec< float,6 > * >(argp2);
result = ((cv::Vec< float,6 > const *)arg1)->mul((cv::Vec< float,6 > const &)*arg2);
resultobj = SWIG_NewPointerObj((new cv::Vec< float,6 >(static_cast< const cv::Vec< float,6 >& >(result))), SWIGTYPE_p_cv__VecT_float_6_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Vec_float_6___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Vec< float,6 > *arg1 = (cv::Vec< float,6 > *) 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:_Vec_float_6___call__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__VecT_float_6_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Vec_float_6___call__" "', argument " "1"" of type '" "cv::Vec< float,6 > const *""'");
}
arg1 = reinterpret_cast< cv::Vec< float,6 > * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_Vec_float_6___call__" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
result = (float *) &((cv::Vec< float,6 > const *)arg1)->operator ()(arg2);
resultobj = SWIG_From_float(static_cast< float >(*result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Vec_float_6__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< float,6,1 > *arg1 = 0 ;
cv::Matx< float,6,1 > *arg2 = 0 ;
cv::Matx_AddOp 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 ;
cv::Vec< float,6 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Vec_float_6",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_float_6_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Vec_float_6" "', argument " "1"" of type '" "cv::Matx< float,6,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_float_6" "', argument " "1"" of type '" "cv::Matx< float,6,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< float,6,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_float_6_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Vec_float_6" "', argument " "2"" of type '" "cv::Matx< float,6,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_float_6" "', argument " "2"" of type '" "cv::Matx< float,6,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< float,6,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_AddOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Vec_float_6" "', argument " "3"" of type '" "cv::Matx_AddOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_float_6" "', argument " "3"" of type '" "cv::Matx_AddOp""'");
} else {
cv::Matx_AddOp * temp = reinterpret_cast< cv::Matx_AddOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Vec< float,6 > *)new cv::Vec< float,6 >((cv::Matx< float,6,1 > const &)*arg1,(cv::Matx< float,6,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__VecT_float_6_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Vec_float_6__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< float,6,1 > *arg1 = 0 ;
cv::Matx< float,6,1 > *arg2 = 0 ;
cv::Matx_SubOp 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 ;
cv::Vec< float,6 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Vec_float_6",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_float_6_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Vec_float_6" "', argument " "1"" of type '" "cv::Matx< float,6,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_float_6" "', argument " "1"" of type '" "cv::Matx< float,6,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< float,6,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_float_6_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Vec_float_6" "', argument " "2"" of type '" "cv::Matx< float,6,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_float_6" "', argument " "2"" of type '" "cv::Matx< float,6,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< float,6,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_SubOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Vec_float_6" "', argument " "3"" of type '" "cv::Matx_SubOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_float_6" "', argument " "3"" of type '" "cv::Matx_SubOp""'");
} else {
cv::Matx_SubOp * temp = reinterpret_cast< cv::Matx_SubOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Vec< float,6 > *)new cv::Vec< float,6 >((cv::Matx< float,6,1 > const &)*arg1,(cv::Matx< float,6,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__VecT_float_6_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Vec_float_6__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< cv::Vec< float,6 >::value_type,std::allocator< cv::Vec< float,6 >::value_type > > arg1 ;
PyObject * obj0 = 0 ;
cv::Vec< float,6 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__Vec_float_6",&obj0)) SWIG_fail;
{
std::vector< float,std::allocator< float > > *ptr = (std::vector< float,std::allocator< float > > *)0;
int res = swig::asptr(obj0, &ptr);
if (!SWIG_IsOK(res) || !ptr) {
SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new__Vec_float_6" "', argument " "1"" of type '" "std::vector< cv::Vec< float,6 >::value_type,std::allocator< cv::Vec< float,6 >::value_type > >""'");
}
arg1 = *ptr;
if (SWIG_IsNewObj(res)) delete ptr;
}
result = (cv::Vec< float,6 > *)new_cv_Vec_Sl_float_Sc_6_Sg___SWIG_4(arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__VecT_float_6_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Vec_float_6(PyObject *self, PyObject *args) {
Py_ssize_t argc;
PyObject *argv[4] = {
0
};
Py_ssize_t ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = args ? PyObject_Length(args) : 0;
for (ii = 0; (ii < 3) && (ii < argc); 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_float, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Vec_float_6__SWIG_0(self, args);
}
}
if (argc == 1) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__VecT_float_6_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Vec_float_6__SWIG_1(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__Vec_float_6__SWIG_4(self, args);
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_float_6_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_float_6_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_SubOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Vec_float_6__SWIG_3(self, args);
}
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_float_6_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_float_6_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_AddOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Vec_float_6__SWIG_2(self, args);
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new__Vec_float_6'.\n"
" Possible C/C++ prototypes are:\n"
" cv::Vec< float,6 >::Vec(float const *)\n"
" cv::Vec< float,6 >::Vec(cv::Vec< float,6 > const &)\n"
" cv::Vec< float,6 >::Vec(cv::Matx< float,6,1 > const &,cv::Matx< float,6,1 > const &,cv::Matx_AddOp)\n"
" cv::Vec< float,6 >::Vec(cv::Matx< float,6,1 > const &,cv::Matx< float,6,1 > const &,cv::Matx_SubOp)\n"
" cv::Vec< float,6 >::Vec(std::vector< cv::Vec< float,6 >::value_type,std::allocator< cv::Vec< float,6 >::value_type > >)\n");
return 0;
}
SWIGINTERN PyObject *_wrap__Vec_float_6___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Vec< float,6 > *arg1 = (cv::Vec< float,6 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
std::string result;
if (!PyArg_ParseTuple(args,(char *)"O:_Vec_float_6___str__",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__VecT_float_6_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Vec_float_6___str__" "', argument " "1"" of type '" "cv::Vec< float,6 > *""'");
}
arg1 = reinterpret_cast< cv::Vec< float,6 > * >(argp1);
result = cv_Vec_Sl_float_Sc_6_Sg____str__(arg1);
resultobj = SWIG_From_std_string(static_cast< std::string >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete__Vec_float_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Vec< float,6 > *arg1 = (cv::Vec< float,6 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete__Vec_float_6",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__VecT_float_6_t, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__Vec_float_6" "', argument " "1"" of type '" "cv::Vec< float,6 > *""'");
}
arg1 = reinterpret_cast< cv::Vec< float,6 > * >(argp1);
delete arg1;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_Vec_float_6_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_cv__VecT_float_6_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_new__DataType_Vec_float_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::DataType< cv::Vec< float,6 > > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new__DataType_Vec_float_6")) SWIG_fail;
result = (cv::DataType< cv::Vec< float,6 > > *)new cv::DataType< cv::Vec< float,6 > >();
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__DataTypeT_cv__VecT_float_6_t_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete__DataType_Vec_float_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::DataType< cv::Vec< float,6 > > *arg1 = (cv::DataType< cv::Vec< float,6 > > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete__DataType_Vec_float_6",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__DataTypeT_cv__VecT_float_6_t_t, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__DataType_Vec_float_6" "', argument " "1"" of type '" "cv::DataType< cv::Vec< float,6 > > *""'");
}
arg1 = reinterpret_cast< cv::DataType< cv::Vec< float,6 > > * >(argp1);
delete arg1;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_DataType_Vec_float_6_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_cv__DataTypeT_cv__VecT_float_6_t_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_new__cv_numpy_sizeof_double(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::_SizeOf< double > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new__cv_numpy_sizeof_double")) SWIG_fail;
result = (cv::_SizeOf< double > *)new cv::_SizeOf< double >();
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv___SizeOfT_double_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete__cv_numpy_sizeof_double(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::_SizeOf< double > *arg1 = (cv::_SizeOf< double > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete__cv_numpy_sizeof_double",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv___SizeOfT_double_t, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__cv_numpy_sizeof_double" "', argument " "1"" of type '" "cv::_SizeOf< double > *""'");
}
arg1 = reinterpret_cast< cv::_SizeOf< double > * >(argp1);
delete arg1;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_cv_numpy_sizeof_double_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_cv___SizeOfT_double_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap__doubleArray_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< double > *arg1 = (std::vector< double > *) 0 ;
PyObject **arg2 = (PyObject **) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
swig::SwigPyIterator *result = 0 ;
arg2 = &obj0;
if (!PyArg_ParseTuple(args,(char *)"O:_doubleArray_iterator",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_doubleArray_iterator" "', argument " "1"" of type '" "std::vector< double > *""'");
}
arg1 = reinterpret_cast< std::vector< double > * >(argp1);
result = (swig::SwigPyIterator *)std_vector_Sl_double_Sg__iterator(arg1,arg2);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__doubleArray___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< double > *arg1 = (std::vector< double > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
bool result;
if (!PyArg_ParseTuple(args,(char *)"O:_doubleArray___nonzero__",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_doubleArray___nonzero__" "', argument " "1"" of type '" "std::vector< double > const *""'");
}
arg1 = reinterpret_cast< std::vector< double > * >(argp1);
result = (bool)std_vector_Sl_double_Sg____nonzero__((std::vector< double > const *)arg1);
resultobj = SWIG_From_bool(static_cast< bool >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__doubleArray___bool__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< double > *arg1 = (std::vector< double > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
bool result;
if (!PyArg_ParseTuple(args,(char *)"O:_doubleArray___bool__",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_doubleArray___bool__" "', argument " "1"" of type '" "std::vector< double > const *""'");
}
arg1 = reinterpret_cast< std::vector< double > * >(argp1);
result = (bool)std_vector_Sl_double_Sg____bool__((std::vector< double > const *)arg1);
resultobj = SWIG_From_bool(static_cast< bool >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__doubleArray___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< double > *arg1 = (std::vector< double > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
std::vector< double >::size_type result;
if (!PyArg_ParseTuple(args,(char *)"O:_doubleArray___len__",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_doubleArray___len__" "', argument " "1"" of type '" "std::vector< double > const *""'");
}
arg1 = reinterpret_cast< std::vector< double > * >(argp1);
result = std_vector_Sl_double_Sg____len__((std::vector< double > const *)arg1);
resultobj = SWIG_From_size_t(static_cast< size_t >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__doubleArray___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< double > *arg1 = (std::vector< double > *) 0 ;
std::vector< double >::difference_type arg2 ;
std::vector< double >::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< double,std::allocator< double > > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:_doubleArray___getslice__",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_doubleArray___getslice__" "', argument " "1"" of type '" "std::vector< double > *""'");
}
arg1 = reinterpret_cast< std::vector< double > * >(argp1);
ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_doubleArray___getslice__" "', argument " "2"" of type '" "std::vector< double >::difference_type""'");
}
arg2 = static_cast< std::vector< double >::difference_type >(val2);
ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "_doubleArray___getslice__" "', argument " "3"" of type '" "std::vector< double >::difference_type""'");
}
arg3 = static_cast< std::vector< double >::difference_type >(val3);
try {
result = (std::vector< double,std::allocator< double > > *)std_vector_Sl_double_Sg____getslice__(arg1,arg2,arg3);
}
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_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__doubleArray___setslice____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< double > *arg1 = (std::vector< double > *) 0 ;
std::vector< double >::difference_type arg2 ;
std::vector< double >::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:_doubleArray___setslice__",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_doubleArray___setslice__" "', argument " "1"" of type '" "std::vector< double > *""'");
}
arg1 = reinterpret_cast< std::vector< double > * >(argp1);
ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_doubleArray___setslice__" "', argument " "2"" of type '" "std::vector< double >::difference_type""'");
}
arg2 = static_cast< std::vector< double >::difference_type >(val2);
ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "_doubleArray___setslice__" "', argument " "3"" of type '" "std::vector< double >::difference_type""'");
}
arg3 = static_cast< std::vector< double >::difference_type >(val3);
try {
std_vector_Sl_double_Sg____setslice____SWIG_0(arg1,arg2,arg3);
}
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();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__doubleArray___setslice____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< double > *arg1 = (std::vector< double > *) 0 ;
std::vector< double >::difference_type arg2 ;
std::vector< double >::difference_type arg3 ;
std::vector< double,std::allocator< double > > *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:_doubleArray___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_doubleArray___setslice__" "', argument " "1"" of type '" "std::vector< double > *""'");
}
arg1 = reinterpret_cast< std::vector< double > * >(argp1);
ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_doubleArray___setslice__" "', argument " "2"" of type '" "std::vector< double >::difference_type""'");
}
arg2 = static_cast< std::vector< double >::difference_type >(val2);
ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "_doubleArray___setslice__" "', argument " "3"" of type '" "std::vector< double >::difference_type""'");
}
arg3 = static_cast< std::vector< double >::difference_type >(val3);
{
std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
res4 = swig::asptr(obj3, &ptr);
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "_doubleArray___setslice__" "', argument " "4"" of type '" "std::vector< double,std::allocator< double > > const &""'");
}
if (!ptr) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_doubleArray___setslice__" "', argument " "4"" of type '" "std::vector< double,std::allocator< double > > const &""'");
}
arg4 = ptr;
}
try {
std_vector_Sl_double_Sg____setslice____SWIG_1(arg1,arg2,arg3,(std::vector< double,std::allocator< double > > 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__doubleArray___setslice__(PyObject *self, PyObject *args) {
Py_ssize_t argc;
PyObject *argv[5] = {
0
};
Py_ssize_t ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = args ? PyObject_Length(args) : 0;
for (ii = 0; (ii < 4) && (ii < argc); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 3) {
int _v;
int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap__doubleArray___setslice____SWIG_0(self, args);
}
}
}
}
if (argc == 4) {
int _v;
int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
int res = swig::asptr(argv[3], (std::vector< double,std::allocator< double > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
return _wrap__doubleArray___setslice____SWIG_1(self, args);
}
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function '_doubleArray___setslice__'.\n"
" Possible C/C++ prototypes are:\n"
" std::vector< double >::__setslice__(std::vector< double >::difference_type,std::vector< double >::difference_type)\n"
" std::vector< double >::__setslice__(std::vector< double >::difference_type,std::vector< double >::difference_type,std::vector< double,std::allocator< double > > const &)\n");
return 0;
}
SWIGINTERN PyObject *_wrap__doubleArray___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< double > *arg1 = (std::vector< double > *) 0 ;
std::vector< double >::difference_type arg2 ;
std::vector< double >::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:_doubleArray___delslice__",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_doubleArray___delslice__" "', argument " "1"" of type '" "std::vector< double > *""'");
}
arg1 = reinterpret_cast< std::vector< double > * >(argp1);
ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_doubleArray___delslice__" "', argument " "2"" of type '" "std::vector< double >::difference_type""'");
}
arg2 = static_cast< std::vector< double >::difference_type >(val2);
ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "_doubleArray___delslice__" "', argument " "3"" of type '" "std::vector< double >::difference_type""'");
}
arg3 = static_cast< std::vector< double >::difference_type >(val3);
try {
std_vector_Sl_double_Sg____delslice__(arg1,arg2,arg3);
}
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();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__doubleArray___delitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< double > *arg1 = (std::vector< double > *) 0 ;
std::vector< double >::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:_doubleArray___delitem__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_doubleArray___delitem__" "', argument " "1"" of type '" "std::vector< double > *""'");
}
arg1 = reinterpret_cast< std::vector< double > * >(argp1);
ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_doubleArray___delitem__" "', argument " "2"" of type '" "std::vector< double >::difference_type""'");
}
arg2 = static_cast< std::vector< double >::difference_type >(val2);
try {
std_vector_Sl_double_Sg____delitem____SWIG_0(arg1,arg2);
}
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();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__doubleArray___getitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< double > *arg1 = (std::vector< double > *) 0 ;
PySliceObject *arg2 = (PySliceObject *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
std::vector< double,std::allocator< double > > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:_doubleArray___getitem__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_doubleArray___getitem__" "', argument " "1"" of type '" "std::vector< double > *""'");
}
arg1 = reinterpret_cast< std::vector< double > * >(argp1);
{
if (!PySlice_Check(obj1)) {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "_doubleArray___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
arg2 = (PySliceObject *) obj1;
}
try {
result = (std::vector< double,std::allocator< double > > *)std_vector_Sl_double_Sg____getitem____SWIG_0(arg1,arg2);
}
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_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__doubleArray___setitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< double > *arg1 = (std::vector< double > *) 0 ;
PySliceObject *arg2 = (PySliceObject *) 0 ;
std::vector< double,std::allocator< double > > *arg3 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res3 = SWIG_OLDOBJ ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:_doubleArray___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_doubleArray___setitem__" "', argument " "1"" of type '" "std::vector< double > *""'");
}
arg1 = reinterpret_cast< std::vector< double > * >(argp1);
{
if (!PySlice_Check(obj1)) {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "_doubleArray___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
arg2 = (PySliceObject *) obj1;
}
{
std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
res3 = swig::asptr(obj2, &ptr);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "_doubleArray___setitem__" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'");
}
if (!ptr) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_doubleArray___setitem__" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'");
}
arg3 = ptr;
}
try {
std_vector_Sl_double_Sg____setitem____SWIG_0(arg1,arg2,(std::vector< double,std::allocator< double > > const &)*arg3);
}
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(res3)) delete arg3;
return resultobj;
fail:
if (SWIG_IsNewObj(res3)) delete arg3;
return NULL;
}
SWIGINTERN PyObject *_wrap__doubleArray___setitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< double > *arg1 = (std::vector< double > *) 0 ;
PySliceObject *arg2 = (PySliceObject *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:_doubleArray___setitem__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_doubleArray___setitem__" "', argument " "1"" of type '" "std::vector< double > *""'");
}
arg1 = reinterpret_cast< std::vector< double > * >(argp1);
{
if (!PySlice_Check(obj1)) {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "_doubleArray___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
arg2 = (PySliceObject *) obj1;
}
try {
std_vector_Sl_double_Sg____setitem____SWIG_1(arg1,arg2);
}
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();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__doubleArray___delitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< double > *arg1 = (std::vector< double > *) 0 ;
PySliceObject *arg2 = (PySliceObject *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:_doubleArray___delitem__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_doubleArray___delitem__" "', argument " "1"" of type '" "std::vector< double > *""'");
}
arg1 = reinterpret_cast< std::vector< double > * >(argp1);
{
if (!PySlice_Check(obj1)) {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "_doubleArray___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
arg2 = (PySliceObject *) obj1;
}
try {
std_vector_Sl_double_Sg____delitem____SWIG_1(arg1,arg2);
}
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();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__doubleArray___delitem__(PyObject *self, PyObject *args) {
Py_ssize_t argc;
PyObject *argv[3] = {
0
};
Py_ssize_t ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = args ? PyObject_Length(args) : 0;
for (ii = 0; (ii < 2) && (ii < argc); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 2) {
int _v;
int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
{
_v = PySlice_Check(argv[1]);
}
if (_v) {
return _wrap__doubleArray___delitem____SWIG_1(self, args);
}
}
}
if (argc == 2) {
int _v;
int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap__doubleArray___delitem____SWIG_0(self, args);
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function '_doubleArray___delitem__'.\n"
" Possible C/C++ prototypes are:\n"
" std::vector< double >::__delitem__(std::vector< double >::difference_type)\n"
" std::vector< double >::__delitem__(PySliceObject *)\n");
return 0;
}
SWIGINTERN PyObject *_wrap__doubleArray___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< double > *arg1 = (std::vector< double > *) 0 ;
std::vector< double >::difference_type arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
ptrdiff_t val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
std::vector< double >::value_type *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:_doubleArray___getitem__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_doubleArray___getitem__" "', argument " "1"" of type '" "std::vector< double > const *""'");
}
arg1 = reinterpret_cast< std::vector< double > * >(argp1);
ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_doubleArray___getitem__" "', argument " "2"" of type '" "std::vector< double >::difference_type""'");
}
arg2 = static_cast< std::vector< double >::difference_type >(val2);
try {
result = (std::vector< double >::value_type *) &std_vector_Sl_double_Sg____getitem____SWIG_1((std::vector< double > const *)arg1,arg2);
}
catch(std::out_of_range &_e) {
SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
}
resultobj = SWIG_From_double(static_cast< double >(*result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__doubleArray___getitem__(PyObject *self, PyObject *args) {
Py_ssize_t argc;
PyObject *argv[3] = {
0
};
Py_ssize_t ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = args ? PyObject_Length(args) : 0;
for (ii = 0; (ii < 2) && (ii < argc); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 2) {
int _v;
int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
{
_v = PySlice_Check(argv[1]);
}
if (_v) {
return _wrap__doubleArray___getitem____SWIG_0(self, args);
}
}
}
if (argc == 2) {
int _v;
int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap__doubleArray___getitem____SWIG_1(self, args);
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function '_doubleArray___getitem__'.\n"
" Possible C/C++ prototypes are:\n"
" std::vector< double >::__getitem__(PySliceObject *)\n"
" std::vector< double >::__getitem__(std::vector< double >::difference_type) const\n");
return 0;
}
SWIGINTERN PyObject *_wrap__doubleArray___setitem____SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< double > *arg1 = (std::vector< double > *) 0 ;
std::vector< double >::difference_type arg2 ;
std::vector< double >::value_type *arg3 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
ptrdiff_t val2 ;
int ecode2 = 0 ;
std::vector< double >::value_type temp3 ;
double val3 ;
int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:_doubleArray___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_doubleArray___setitem__" "', argument " "1"" of type '" "std::vector< double > *""'");
}
arg1 = reinterpret_cast< std::vector< double > * >(argp1);
ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_doubleArray___setitem__" "', argument " "2"" of type '" "std::vector< double >::difference_type""'");
}
arg2 = static_cast< std::vector< double >::difference_type >(val2);
ecode3 = SWIG_AsVal_double(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "_doubleArray___setitem__" "', argument " "3"" of type '" "std::vector< double >::value_type""'");
}
temp3 = static_cast< std::vector< double >::value_type >(val3);
arg3 = &temp3;
try {
std_vector_Sl_double_Sg____setitem____SWIG_2(arg1,arg2,(double 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__doubleArray___setitem__(PyObject *self, PyObject *args) {
Py_ssize_t argc;
PyObject *argv[4] = {
0
};
Py_ssize_t ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = args ? PyObject_Length(args) : 0;
for (ii = 0; (ii < 3) && (ii < argc); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 2) {
int _v;
int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
{
_v = PySlice_Check(argv[1]);
}
if (_v) {
return _wrap__doubleArray___setitem____SWIG_1(self, args);
}
}
}
if (argc == 3) {
int _v;
int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
{
_v = PySlice_Check(argv[1]);
}
if (_v) {
int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
return _wrap__doubleArray___setitem____SWIG_0(self, args);
}
}
}
}
if (argc == 3) {
int _v;
int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_ptrdiff_t(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__doubleArray___setitem____SWIG_2(self, args);
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function '_doubleArray___setitem__'.\n"
" Possible C/C++ prototypes are:\n"
" std::vector< double >::__setitem__(PySliceObject *,std::vector< double,std::allocator< double > > const &)\n"
" std::vector< double >::__setitem__(PySliceObject *)\n"
" std::vector< double >::__setitem__(std::vector< double >::difference_type,std::vector< double >::value_type const &)\n");
return 0;
}
SWIGINTERN PyObject *_wrap__doubleArray_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< double > *arg1 = (std::vector< double > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
std::vector< double >::value_type result;
if (!PyArg_ParseTuple(args,(char *)"O:_doubleArray_pop",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_doubleArray_pop" "', argument " "1"" of type '" "std::vector< double > *""'");
}
arg1 = reinterpret_cast< std::vector< double > * >(argp1);
try {
result = (std::vector< double >::value_type)std_vector_Sl_double_Sg__pop(arg1);
}
catch(std::out_of_range &_e) {
SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
}
resultobj = SWIG_From_double(static_cast< double >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__doubleArray_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< double > *arg1 = (std::vector< double > *) 0 ;
std::vector< double >::value_type *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
std::vector< double >::value_type temp2 ;
double val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:_doubleArray_append",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_doubleArray_append" "', argument " "1"" of type '" "std::vector< double > *""'");
}
arg1 = reinterpret_cast< std::vector< double > * >(argp1);
ecode2 = SWIG_AsVal_double(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_doubleArray_append" "', argument " "2"" of type '" "std::vector< double >::value_type""'");
}
temp2 = static_cast< std::vector< double >::value_type >(val2);
arg2 = &temp2;
std_vector_Sl_double_Sg__append(arg1,(double const &)*arg2);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__doubleArray__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< double > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new__doubleArray")) SWIG_fail;
result = (std::vector< double > *)new std::vector< double >();
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__doubleArray__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< double > *arg1 = 0 ;
int res1 = SWIG_OLDOBJ ;
PyObject * obj0 = 0 ;
std::vector< double > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__doubleArray",&obj0)) SWIG_fail;
{
std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
res1 = swig::asptr(obj0, &ptr);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__doubleArray" "', argument " "1"" of type '" "std::vector< double > const &""'");
}
if (!ptr) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__doubleArray" "', argument " "1"" of type '" "std::vector< double > const &""'");
}
arg1 = ptr;
}
result = (std::vector< double > *)new std::vector< double >((std::vector< double > const &)*arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_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__doubleArray_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< double > *arg1 = (std::vector< double > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
bool result;
if (!PyArg_ParseTuple(args,(char *)"O:_doubleArray_empty",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_doubleArray_empty" "', argument " "1"" of type '" "std::vector< double > const *""'");
}
arg1 = reinterpret_cast< std::vector< double > * >(argp1);
result = (bool)((std::vector< double > const *)arg1)->empty();
resultobj = SWIG_From_bool(static_cast< bool >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__doubleArray_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< double > *arg1 = (std::vector< double > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
std::vector< double >::size_type result;
if (!PyArg_ParseTuple(args,(char *)"O:_doubleArray_size",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_doubleArray_size" "', argument " "1"" of type '" "std::vector< double > const *""'");
}
arg1 = reinterpret_cast< std::vector< double > * >(argp1);
result = ((std::vector< double > const *)arg1)->size();
resultobj = SWIG_From_size_t(static_cast< size_t >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__doubleArray_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< double > *arg1 = (std::vector< double > *) 0 ;
std::vector< double > *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:_doubleArray_swap",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_doubleArray_swap" "', argument " "1"" of type '" "std::vector< double > *""'");
}
arg1 = reinterpret_cast< std::vector< double > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_doubleArray_swap" "', argument " "2"" of type '" "std::vector< double > &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_doubleArray_swap" "', argument " "2"" of type '" "std::vector< double > &""'");
}
arg2 = reinterpret_cast< std::vector< double > * >(argp2);
(arg1)->swap(*arg2);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__doubleArray_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< double > *arg1 = (std::vector< double > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
std::vector< double >::iterator result;
if (!PyArg_ParseTuple(args,(char *)"O:_doubleArray_begin",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_doubleArray_begin" "', argument " "1"" of type '" "std::vector< double > *""'");
}
arg1 = reinterpret_cast< std::vector< double > * >(argp1);
result = (arg1)->begin();
resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< double >::iterator & >(result)),
swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__doubleArray_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< double > *arg1 = (std::vector< double > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
std::vector< double >::iterator result;
if (!PyArg_ParseTuple(args,(char *)"O:_doubleArray_end",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_doubleArray_end" "', argument " "1"" of type '" "std::vector< double > *""'");
}
arg1 = reinterpret_cast< std::vector< double > * >(argp1);
result = (arg1)->end();
resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< double >::iterator & >(result)),
swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__doubleArray_rbegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< double > *arg1 = (std::vector< double > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
std::vector< double >::reverse_iterator result;
if (!PyArg_ParseTuple(args,(char *)"O:_doubleArray_rbegin",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_doubleArray_rbegin" "', argument " "1"" of type '" "std::vector< double > *""'");
}
arg1 = reinterpret_cast< std::vector< double > * >(argp1);
result = (arg1)->rbegin();
resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< double >::reverse_iterator & >(result)),
swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__doubleArray_rend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< double > *arg1 = (std::vector< double > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
std::vector< double >::reverse_iterator result;
if (!PyArg_ParseTuple(args,(char *)"O:_doubleArray_rend",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_doubleArray_rend" "', argument " "1"" of type '" "std::vector< double > *""'");
}
arg1 = reinterpret_cast< std::vector< double > * >(argp1);
result = (arg1)->rend();
resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< double >::reverse_iterator & >(result)),
swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__doubleArray_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< double > *arg1 = (std::vector< double > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:_doubleArray_clear",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_doubleArray_clear" "', argument " "1"" of type '" "std::vector< double > *""'");
}
arg1 = reinterpret_cast< std::vector< double > * >(argp1);
(arg1)->clear();
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__doubleArray_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< double > *arg1 = (std::vector< double > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
SwigValueWrapper< std::allocator< double > > result;
if (!PyArg_ParseTuple(args,(char *)"O:_doubleArray_get_allocator",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_doubleArray_get_allocator" "', argument " "1"" of type '" "std::vector< double > const *""'");
}
arg1 = reinterpret_cast< std::vector< double > * >(argp1);
result = ((std::vector< double > const *)arg1)->get_allocator();
resultobj = SWIG_NewPointerObj((new std::vector< double >::allocator_type(static_cast< const std::vector< double >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_double_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__doubleArray__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< double >::size_type arg1 ;
size_t val1 ;
int ecode1 = 0 ;
PyObject * obj0 = 0 ;
std::vector< double > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__doubleArray",&obj0)) SWIG_fail;
ecode1 = SWIG_AsVal_size_t(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new__doubleArray" "', argument " "1"" of type '" "std::vector< double >::size_type""'");
}
arg1 = static_cast< std::vector< double >::size_type >(val1);
result = (std::vector< double > *)new std::vector< double >(arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__doubleArray_pop_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< double > *arg1 = (std::vector< double > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:_doubleArray_pop_back",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_doubleArray_pop_back" "', argument " "1"" of type '" "std::vector< double > *""'");
}
arg1 = reinterpret_cast< std::vector< double > * >(argp1);
(arg1)->pop_back();
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__doubleArray_resize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< double > *arg1 = (std::vector< double > *) 0 ;
std::vector< double >::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:_doubleArray_resize",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_doubleArray_resize" "', argument " "1"" of type '" "std::vector< double > *""'");
}
arg1 = reinterpret_cast< std::vector< double > * >(argp1);
ecode2 = SWIG_AsVal_size_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_doubleArray_resize" "', argument " "2"" of type '" "std::vector< double >::size_type""'");
}
arg2 = static_cast< std::vector< double >::size_type >(val2);
(arg1)->resize(arg2);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__doubleArray_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< double > *arg1 = (std::vector< double > *) 0 ;
std::vector< double >::iterator arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
swig::SwigPyIterator *iter2 = 0 ;
int res2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
std::vector< double >::iterator result;
if (!PyArg_ParseTuple(args,(char *)"OO:_doubleArray_erase",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_doubleArray_erase" "', argument " "1"" of type '" "std::vector< double > *""'");
}
arg1 = reinterpret_cast< std::vector< double > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
if (!SWIG_IsOK(res2) || !iter2) {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "_doubleArray_erase" "', argument " "2"" of type '" "std::vector< double >::iterator""'");
} else {
swig::SwigPyIterator_T<std::vector< double >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< double >::iterator > *>(iter2);
if (iter_t) {
arg2 = iter_t->get_current();
} else {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "_doubleArray_erase" "', argument " "2"" of type '" "std::vector< double >::iterator""'");
}
}
result = std_vector_Sl_double_Sg__erase__SWIG_0(arg1,arg2);
resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< double >::iterator & >(result)),
swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__doubleArray_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< double > *arg1 = (std::vector< double > *) 0 ;
std::vector< double >::iterator arg2 ;
std::vector< double >::iterator arg3 ;
void *argp1 = 0 ;
int res1 = 0 ;
swig::SwigPyIterator *iter2 = 0 ;
int res2 ;
swig::SwigPyIterator *iter3 = 0 ;
int res3 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
std::vector< double >::iterator result;
if (!PyArg_ParseTuple(args,(char *)"OOO:_doubleArray_erase",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_doubleArray_erase" "', argument " "1"" of type '" "std::vector< double > *""'");
}
arg1 = reinterpret_cast< std::vector< double > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
if (!SWIG_IsOK(res2) || !iter2) {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "_doubleArray_erase" "', argument " "2"" of type '" "std::vector< double >::iterator""'");
} else {
swig::SwigPyIterator_T<std::vector< double >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< double >::iterator > *>(iter2);
if (iter_t) {
arg2 = iter_t->get_current();
} else {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "_doubleArray_erase" "', argument " "2"" of type '" "std::vector< double >::iterator""'");
}
}
res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
if (!SWIG_IsOK(res3) || !iter3) {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "_doubleArray_erase" "', argument " "3"" of type '" "std::vector< double >::iterator""'");
} else {
swig::SwigPyIterator_T<std::vector< double >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< double >::iterator > *>(iter3);
if (iter_t) {
arg3 = iter_t->get_current();
} else {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "_doubleArray_erase" "', argument " "3"" of type '" "std::vector< double >::iterator""'");
}
}
result = std_vector_Sl_double_Sg__erase__SWIG_1(arg1,arg2,arg3);
resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< double >::iterator & >(result)),
swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__doubleArray_erase(PyObject *self, PyObject *args) {
Py_ssize_t argc;
PyObject *argv[4] = {
0
};
Py_ssize_t ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = args ? PyObject_Length(args) : 0;
for (ii = 0; (ii < 3) && (ii < argc); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 2) {
int _v;
int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
swig::SwigPyIterator *iter = 0;
int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
_v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< double >::iterator > *>(iter) != 0));
if (_v) {
return _wrap__doubleArray_erase__SWIG_0(self, args);
}
}
}
if (argc == 3) {
int _v;
int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
swig::SwigPyIterator *iter = 0;
int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
_v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< double >::iterator > *>(iter) != 0));
if (_v) {
swig::SwigPyIterator *iter = 0;
int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
_v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< double >::iterator > *>(iter) != 0));
if (_v) {
return _wrap__doubleArray_erase__SWIG_1(self, args);
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function '_doubleArray_erase'.\n"
" Possible C/C++ prototypes are:\n"
" std::vector< double >::erase(std::vector< double >::iterator)\n"
" std::vector< double >::erase(std::vector< double >::iterator,std::vector< double >::iterator)\n");
return 0;
}
SWIGINTERN PyObject *_wrap_new__doubleArray__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< double >::size_type arg1 ;
std::vector< double >::value_type *arg2 = 0 ;
size_t val1 ;
int ecode1 = 0 ;
std::vector< double >::value_type temp2 ;
double val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
std::vector< double > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:new__doubleArray",&obj0,&obj1)) SWIG_fail;
ecode1 = SWIG_AsVal_size_t(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new__doubleArray" "', argument " "1"" of type '" "std::vector< double >::size_type""'");
}
arg1 = static_cast< std::vector< double >::size_type >(val1);
ecode2 = SWIG_AsVal_double(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new__doubleArray" "', argument " "2"" of type '" "std::vector< double >::value_type""'");
}
temp2 = static_cast< std::vector< double >::value_type >(val2);
arg2 = &temp2;
result = (std::vector< double > *)new std::vector< double >(arg1,(std::vector< double >::value_type const &)*arg2);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__doubleArray(PyObject *self, PyObject *args) {
Py_ssize_t argc;
PyObject *argv[3] = {
0
};
Py_ssize_t ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = args ? PyObject_Length(args) : 0;
for (ii = 0; (ii < 2) && (ii < argc); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 0) {
return _wrap_new__doubleArray__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__doubleArray__SWIG_2(self, args);
}
}
if (argc == 1) {
int _v;
int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__doubleArray__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_double(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_new__doubleArray__SWIG_3(self, args);
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new__doubleArray'.\n"
" Possible C/C++ prototypes are:\n"
" std::vector< double >::vector()\n"
" std::vector< double >::vector(std::vector< double > const &)\n"
" std::vector< double >::vector(std::vector< double >::size_type)\n"
" std::vector< double >::vector(std::vector< double >::size_type,std::vector< double >::value_type const &)\n");
return 0;
}
SWIGINTERN PyObject *_wrap__doubleArray_push_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< double > *arg1 = (std::vector< double > *) 0 ;
std::vector< double >::value_type *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
std::vector< double >::value_type temp2 ;
double val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:_doubleArray_push_back",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_doubleArray_push_back" "', argument " "1"" of type '" "std::vector< double > *""'");
}
arg1 = reinterpret_cast< std::vector< double > * >(argp1);
ecode2 = SWIG_AsVal_double(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_doubleArray_push_back" "', argument " "2"" of type '" "std::vector< double >::value_type""'");
}
temp2 = static_cast< std::vector< double >::value_type >(val2);
arg2 = &temp2;
(arg1)->push_back((std::vector< double >::value_type const &)*arg2);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__doubleArray_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< double > *arg1 = (std::vector< double > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
std::vector< double >::value_type *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:_doubleArray_front",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_doubleArray_front" "', argument " "1"" of type '" "std::vector< double > const *""'");
}
arg1 = reinterpret_cast< std::vector< double > * >(argp1);
result = (std::vector< double >::value_type *) &((std::vector< double > const *)arg1)->front();
resultobj = SWIG_From_double(static_cast< double >(*result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__doubleArray_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< double > *arg1 = (std::vector< double > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
std::vector< double >::value_type *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:_doubleArray_back",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_doubleArray_back" "', argument " "1"" of type '" "std::vector< double > const *""'");
}
arg1 = reinterpret_cast< std::vector< double > * >(argp1);
result = (std::vector< double >::value_type *) &((std::vector< double > const *)arg1)->back();
resultobj = SWIG_From_double(static_cast< double >(*result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__doubleArray_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< double > *arg1 = (std::vector< double > *) 0 ;
std::vector< double >::size_type arg2 ;
std::vector< double >::value_type *arg3 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
size_t val2 ;
int ecode2 = 0 ;
std::vector< double >::value_type temp3 ;
double val3 ;
int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:_doubleArray_assign",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_doubleArray_assign" "', argument " "1"" of type '" "std::vector< double > *""'");
}
arg1 = reinterpret_cast< std::vector< double > * >(argp1);
ecode2 = SWIG_AsVal_size_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_doubleArray_assign" "', argument " "2"" of type '" "std::vector< double >::size_type""'");
}
arg2 = static_cast< std::vector< double >::size_type >(val2);
ecode3 = SWIG_AsVal_double(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "_doubleArray_assign" "', argument " "3"" of type '" "std::vector< double >::value_type""'");
}
temp3 = static_cast< std::vector< double >::value_type >(val3);
arg3 = &temp3;
(arg1)->assign(arg2,(std::vector< double >::value_type const &)*arg3);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__doubleArray_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< double > *arg1 = (std::vector< double > *) 0 ;
std::vector< double >::size_type arg2 ;
std::vector< double >::value_type *arg3 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
size_t val2 ;
int ecode2 = 0 ;
std::vector< double >::value_type temp3 ;
double val3 ;
int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:_doubleArray_resize",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_doubleArray_resize" "', argument " "1"" of type '" "std::vector< double > *""'");
}
arg1 = reinterpret_cast< std::vector< double > * >(argp1);
ecode2 = SWIG_AsVal_size_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_doubleArray_resize" "', argument " "2"" of type '" "std::vector< double >::size_type""'");
}
arg2 = static_cast< std::vector< double >::size_type >(val2);
ecode3 = SWIG_AsVal_double(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "_doubleArray_resize" "', argument " "3"" of type '" "std::vector< double >::value_type""'");
}
temp3 = static_cast< std::vector< double >::value_type >(val3);
arg3 = &temp3;
(arg1)->resize(arg2,(std::vector< double >::value_type const &)*arg3);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__doubleArray_resize(PyObject *self, PyObject *args) {
Py_ssize_t argc;
PyObject *argv[4] = {
0
};
Py_ssize_t ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = args ? PyObject_Length(args) : 0;
for (ii = 0; (ii < 3) && (ii < argc); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 2) {
int _v;
int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_size_t(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap__doubleArray_resize__SWIG_0(self, args);
}
}
}
if (argc == 3) {
int _v;
int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(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_double(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap__doubleArray_resize__SWIG_1(self, args);
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function '_doubleArray_resize'.\n"
" Possible C/C++ prototypes are:\n"
" std::vector< double >::resize(std::vector< double >::size_type)\n"
" std::vector< double >::resize(std::vector< double >::size_type,std::vector< double >::value_type const &)\n");
return 0;
}
SWIGINTERN PyObject *_wrap__doubleArray_insert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< double > *arg1 = (std::vector< double > *) 0 ;
std::vector< double >::iterator arg2 ;
std::vector< double >::value_type *arg3 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
swig::SwigPyIterator *iter2 = 0 ;
int res2 ;
std::vector< double >::value_type temp3 ;
double val3 ;
int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
std::vector< double >::iterator result;
if (!PyArg_ParseTuple(args,(char *)"OOO:_doubleArray_insert",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_doubleArray_insert" "', argument " "1"" of type '" "std::vector< double > *""'");
}
arg1 = reinterpret_cast< std::vector< double > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
if (!SWIG_IsOK(res2) || !iter2) {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "_doubleArray_insert" "', argument " "2"" of type '" "std::vector< double >::iterator""'");
} else {
swig::SwigPyIterator_T<std::vector< double >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< double >::iterator > *>(iter2);
if (iter_t) {
arg2 = iter_t->get_current();
} else {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "_doubleArray_insert" "', argument " "2"" of type '" "std::vector< double >::iterator""'");
}
}
ecode3 = SWIG_AsVal_double(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "_doubleArray_insert" "', argument " "3"" of type '" "std::vector< double >::value_type""'");
}
temp3 = static_cast< std::vector< double >::value_type >(val3);
arg3 = &temp3;
result = std_vector_Sl_double_Sg__insert__SWIG_0(arg1,arg2,(double const &)*arg3);
resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< double >::iterator & >(result)),
swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__doubleArray_insert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< double > *arg1 = (std::vector< double > *) 0 ;
std::vector< double >::iterator arg2 ;
std::vector< double >::size_type arg3 ;
std::vector< double >::value_type *arg4 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
swig::SwigPyIterator *iter2 = 0 ;
int res2 ;
size_t val3 ;
int ecode3 = 0 ;
std::vector< double >::value_type temp4 ;
double val4 ;
int ecode4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOO:_doubleArray_insert",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_doubleArray_insert" "', argument " "1"" of type '" "std::vector< double > *""'");
}
arg1 = reinterpret_cast< std::vector< double > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
if (!SWIG_IsOK(res2) || !iter2) {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "_doubleArray_insert" "', argument " "2"" of type '" "std::vector< double >::iterator""'");
} else {
swig::SwigPyIterator_T<std::vector< double >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< double >::iterator > *>(iter2);
if (iter_t) {
arg2 = iter_t->get_current();
} else {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "_doubleArray_insert" "', argument " "2"" of type '" "std::vector< double >::iterator""'");
}
}
ecode3 = SWIG_AsVal_size_t(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "_doubleArray_insert" "', argument " "3"" of type '" "std::vector< double >::size_type""'");
}
arg3 = static_cast< std::vector< double >::size_type >(val3);
ecode4 = SWIG_AsVal_double(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "_doubleArray_insert" "', argument " "4"" of type '" "std::vector< double >::value_type""'");
}
temp4 = static_cast< std::vector< double >::value_type >(val4);
arg4 = &temp4;
std_vector_Sl_double_Sg__insert__SWIG_1(arg1,arg2,arg3,(double const &)*arg4);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__doubleArray_insert(PyObject *self, PyObject *args) {
Py_ssize_t argc;
PyObject *argv[5] = {
0
};
Py_ssize_t ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = args ? PyObject_Length(args) : 0;
for (ii = 0; (ii < 4) && (ii < argc); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 3) {
int _v;
int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
swig::SwigPyIterator *iter = 0;
int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
_v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< double >::iterator > *>(iter) != 0));
if (_v) {
{
int res = SWIG_AsVal_double(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap__doubleArray_insert__SWIG_0(self, args);
}
}
}
}
if (argc == 4) {
int _v;
int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
swig::SwigPyIterator *iter = 0;
int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
_v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< double >::iterator > *>(iter) != 0));
if (_v) {
{
int res = SWIG_AsVal_size_t(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__doubleArray_insert__SWIG_1(self, args);
}
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function '_doubleArray_insert'.\n"
" Possible C/C++ prototypes are:\n"
" std::vector< double >::insert(std::vector< double >::iterator,std::vector< double >::value_type const &)\n"
" std::vector< double >::insert(std::vector< double >::iterator,std::vector< double >::size_type,std::vector< double >::value_type const &)\n");
return 0;
}
SWIGINTERN PyObject *_wrap__doubleArray_reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< double > *arg1 = (std::vector< double > *) 0 ;
std::vector< double >::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:_doubleArray_reserve",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_doubleArray_reserve" "', argument " "1"" of type '" "std::vector< double > *""'");
}
arg1 = reinterpret_cast< std::vector< double > * >(argp1);
ecode2 = SWIG_AsVal_size_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_doubleArray_reserve" "', argument " "2"" of type '" "std::vector< double >::size_type""'");
}
arg2 = static_cast< std::vector< double >::size_type >(val2);
(arg1)->reserve(arg2);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__doubleArray_capacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< double > *arg1 = (std::vector< double > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
std::vector< double >::size_type result;
if (!PyArg_ParseTuple(args,(char *)"O:_doubleArray_capacity",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_doubleArray_capacity" "', argument " "1"" of type '" "std::vector< double > const *""'");
}
arg1 = reinterpret_cast< std::vector< double > * >(argp1);
result = ((std::vector< double > const *)arg1)->capacity();
resultobj = SWIG_From_size_t(static_cast< size_t >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete__doubleArray(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< double > *arg1 = (std::vector< double > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete__doubleArray",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__doubleArray" "', argument " "1"" of type '" "std::vector< double > *""'");
}
arg1 = reinterpret_cast< std::vector< double > * >(argp1);
delete arg1;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_doubleArray_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_new__Matx_double_2_1__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
double *arg1 = (double *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
cv::Matx< double,2,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__Matx_double_2_1",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_double_2_1" "', argument " "1"" of type '" "double const *""'");
}
arg1 = reinterpret_cast< double * >(argp1);
result = (cv::Matx< double,2,1 > *)new cv::Matx< double,2,1 >((double const *)arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_double_2_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_double_2_1_all(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
double arg1 ;
double val1 ;
int ecode1 = 0 ;
PyObject * obj0 = 0 ;
SwigValueWrapper< cv::Matx< double,2,1 > > result;
if (!PyArg_ParseTuple(args,(char *)"O:_Matx_double_2_1_all",&obj0)) SWIG_fail;
ecode1 = SWIG_AsVal_double(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_Matx_double_2_1_all" "', argument " "1"" of type '" "double""'");
}
arg1 = static_cast< double >(val1);
result = cv::Matx< double,2,1 >::SWIGTEMPLATEDISAMBIGUATOR all(arg1);
resultobj = SWIG_NewPointerObj((new cv::Matx< double,2,1 >(static_cast< const cv::Matx< double,2,1 >& >(result))), SWIGTYPE_p_cv__MatxT_double_2_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_double_2_1_zeros(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
SwigValueWrapper< cv::Matx< double,2,1 > > result;
if (!PyArg_ParseTuple(args,(char *)":_Matx_double_2_1_zeros")) SWIG_fail;
result = cv::Matx< double,2,1 >::SWIGTEMPLATEDISAMBIGUATOR zeros();
resultobj = SWIG_NewPointerObj((new cv::Matx< double,2,1 >(static_cast< const cv::Matx< double,2,1 >& >(result))), SWIGTYPE_p_cv__MatxT_double_2_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_double_2_1_ones(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
SwigValueWrapper< cv::Matx< double,2,1 > > result;
if (!PyArg_ParseTuple(args,(char *)":_Matx_double_2_1_ones")) SWIG_fail;
result = cv::Matx< double,2,1 >::SWIGTEMPLATEDISAMBIGUATOR ones();
resultobj = SWIG_NewPointerObj((new cv::Matx< double,2,1 >(static_cast< const cv::Matx< double,2,1 >& >(result))), SWIGTYPE_p_cv__MatxT_double_2_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_double_2_1_eye(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
SwigValueWrapper< cv::Matx< double,2,1 > > result;
if (!PyArg_ParseTuple(args,(char *)":_Matx_double_2_1_eye")) SWIG_fail;
result = cv::Matx< double,2,1 >::SWIGTEMPLATEDISAMBIGUATOR eye();
resultobj = SWIG_NewPointerObj((new cv::Matx< double,2,1 >(static_cast< const cv::Matx< double,2,1 >& >(result))), SWIGTYPE_p_cv__MatxT_double_2_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_double_2_1_randu(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 ;
SwigValueWrapper< cv::Matx< double,2,1 > > result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_double_2_1_randu",&obj0,&obj1)) SWIG_fail;
ecode1 = SWIG_AsVal_double(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_Matx_double_2_1_randu" "', 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 '" "_Matx_double_2_1_randu" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
result = cv::Matx< double,2,1 >::SWIGTEMPLATEDISAMBIGUATOR randu(arg1,arg2);
resultobj = SWIG_NewPointerObj((new cv::Matx< double,2,1 >(static_cast< const cv::Matx< double,2,1 >& >(result))), SWIGTYPE_p_cv__MatxT_double_2_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_double_2_1_randn(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 ;
SwigValueWrapper< cv::Matx< double,2,1 > > result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_double_2_1_randn",&obj0,&obj1)) SWIG_fail;
ecode1 = SWIG_AsVal_double(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_Matx_double_2_1_randn" "', 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 '" "_Matx_double_2_1_randn" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
result = cv::Matx< double,2,1 >::SWIGTEMPLATEDISAMBIGUATOR randn(arg1,arg2);
resultobj = SWIG_NewPointerObj((new cv::Matx< double,2,1 >(static_cast< const cv::Matx< double,2,1 >& >(result))), SWIGTYPE_p_cv__MatxT_double_2_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_double_2_1_dot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< double,2,1 > *arg1 = (cv::Matx< double,2,1 > *) 0 ;
cv::Matx< double,2,1 > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
double result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_double_2_1_dot",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_double_2_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_double_2_1_dot" "', argument " "1"" of type '" "cv::Matx< double,2,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< double,2,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_double_2_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_double_2_1_dot" "', argument " "2"" of type '" "cv::Matx< double,2,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Matx_double_2_1_dot" "', argument " "2"" of type '" "cv::Matx< double,2,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< double,2,1 > * >(argp2);
result = (double)((cv::Matx< double,2,1 > const *)arg1)->dot((cv::Matx< double,2,1 > const &)*arg2);
resultobj = SWIG_From_double(static_cast< double >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_double_2_1_ddot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< double,2,1 > *arg1 = (cv::Matx< double,2,1 > *) 0 ;
cv::Matx< double,2,1 > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
double result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_double_2_1_ddot",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_double_2_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_double_2_1_ddot" "', argument " "1"" of type '" "cv::Matx< double,2,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< double,2,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_double_2_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_double_2_1_ddot" "', argument " "2"" of type '" "cv::Matx< double,2,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Matx_double_2_1_ddot" "', argument " "2"" of type '" "cv::Matx< double,2,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< double,2,1 > * >(argp2);
result = (double)((cv::Matx< double,2,1 > const *)arg1)->ddot((cv::Matx< double,2,1 > const &)*arg2);
resultobj = SWIG_From_double(static_cast< double >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_double_2_1_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< double,2,1 > *arg1 = (cv::Matx< double,2,1 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
SwigValueWrapper< cv::Matx< double,1,2 > > result;
if (!PyArg_ParseTuple(args,(char *)"O:_Matx_double_2_1_t",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_double_2_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_double_2_1_t" "', argument " "1"" of type '" "cv::Matx< double,2,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< double,2,1 > * >(argp1);
result = ((cv::Matx< double,2,1 > const *)arg1)->t();
resultobj = SWIG_NewPointerObj((new cv::Matx< double,1,2 >(static_cast< const cv::Matx< double,1,2 >& >(result))), SWIGTYPE_p_cv__MatxT_double_1_2_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_double_2_1_mul(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< double,2,1 > *arg1 = (cv::Matx< double,2,1 > *) 0 ;
cv::Matx< double,2,1 > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
SwigValueWrapper< cv::Matx< double,2,1 > > result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_double_2_1_mul",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_double_2_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_double_2_1_mul" "', argument " "1"" of type '" "cv::Matx< double,2,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< double,2,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_double_2_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_double_2_1_mul" "', argument " "2"" of type '" "cv::Matx< double,2,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Matx_double_2_1_mul" "', argument " "2"" of type '" "cv::Matx< double,2,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< double,2,1 > * >(argp2);
result = ((cv::Matx< double,2,1 > const *)arg1)->mul((cv::Matx< double,2,1 > const &)*arg2);
resultobj = SWIG_NewPointerObj((new cv::Matx< double,2,1 >(static_cast< const cv::Matx< double,2,1 >& >(result))), SWIGTYPE_p_cv__MatxT_double_2_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_double_2_1_div(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< double,2,1 > *arg1 = (cv::Matx< double,2,1 > *) 0 ;
cv::Matx< double,2,1 > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
SwigValueWrapper< cv::Matx< double,2,1 > > result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_double_2_1_div",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_double_2_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_double_2_1_div" "', argument " "1"" of type '" "cv::Matx< double,2,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< double,2,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_double_2_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_double_2_1_div" "', argument " "2"" of type '" "cv::Matx< double,2,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Matx_double_2_1_div" "', argument " "2"" of type '" "cv::Matx< double,2,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< double,2,1 > * >(argp2);
result = ((cv::Matx< double,2,1 > const *)arg1)->div((cv::Matx< double,2,1 > const &)*arg2);
resultobj = SWIG_NewPointerObj((new cv::Matx< double,2,1 >(static_cast< const cv::Matx< double,2,1 >& >(result))), SWIGTYPE_p_cv__MatxT_double_2_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_double_2_1___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< double,2,1 > *arg1 = (cv::Matx< double,2,1 > *) 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 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:_Matx_double_2_1___call__",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_double_2_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_double_2_1___call__" "', argument " "1"" of type '" "cv::Matx< double,2,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< double,2,1 > * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_Matx_double_2_1___call__" "', 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 '" "_Matx_double_2_1___call__" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
result = (double *) &((cv::Matx< double,2,1 > const *)arg1)->operator ()(arg2,arg3);
resultobj = SWIG_From_double(static_cast< double >(*result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_double_2_1__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< double,2,1 > *arg1 = 0 ;
cv::Matx< double,2,1 > *arg2 = 0 ;
cv::Matx_AddOp 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 ;
cv::Matx< double,2,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Matx_double_2_1",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_double_2_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_double_2_1" "', argument " "1"" of type '" "cv::Matx< double,2,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_double_2_1" "', argument " "1"" of type '" "cv::Matx< double,2,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< double,2,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_double_2_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Matx_double_2_1" "', argument " "2"" of type '" "cv::Matx< double,2,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_double_2_1" "', argument " "2"" of type '" "cv::Matx< double,2,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< double,2,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_AddOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Matx_double_2_1" "', argument " "3"" of type '" "cv::Matx_AddOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_double_2_1" "', argument " "3"" of type '" "cv::Matx_AddOp""'");
} else {
cv::Matx_AddOp * temp = reinterpret_cast< cv::Matx_AddOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Matx< double,2,1 > *)new cv::Matx< double,2,1 >((cv::Matx< double,2,1 > const &)*arg1,(cv::Matx< double,2,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_double_2_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_double_2_1__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< double,2,1 > *arg1 = 0 ;
cv::Matx< double,2,1 > *arg2 = 0 ;
cv::Matx_SubOp 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 ;
cv::Matx< double,2,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Matx_double_2_1",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_double_2_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_double_2_1" "', argument " "1"" of type '" "cv::Matx< double,2,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_double_2_1" "', argument " "1"" of type '" "cv::Matx< double,2,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< double,2,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_double_2_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Matx_double_2_1" "', argument " "2"" of type '" "cv::Matx< double,2,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_double_2_1" "', argument " "2"" of type '" "cv::Matx< double,2,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< double,2,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_SubOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Matx_double_2_1" "', argument " "3"" of type '" "cv::Matx_SubOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_double_2_1" "', argument " "3"" of type '" "cv::Matx_SubOp""'");
} else {
cv::Matx_SubOp * temp = reinterpret_cast< cv::Matx_SubOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Matx< double,2,1 > *)new cv::Matx< double,2,1 >((cv::Matx< double,2,1 > const &)*arg1,(cv::Matx< double,2,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_double_2_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_double_2_1__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< double,2,1 > *arg1 = 0 ;
cv::Matx< double,2,1 > *arg2 = 0 ;
cv::Matx_MulOp 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 ;
cv::Matx< double,2,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Matx_double_2_1",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_double_2_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_double_2_1" "', argument " "1"" of type '" "cv::Matx< double,2,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_double_2_1" "', argument " "1"" of type '" "cv::Matx< double,2,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< double,2,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_double_2_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Matx_double_2_1" "', argument " "2"" of type '" "cv::Matx< double,2,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_double_2_1" "', argument " "2"" of type '" "cv::Matx< double,2,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< double,2,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_MulOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Matx_double_2_1" "', argument " "3"" of type '" "cv::Matx_MulOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_double_2_1" "', argument " "3"" of type '" "cv::Matx_MulOp""'");
} else {
cv::Matx_MulOp * temp = reinterpret_cast< cv::Matx_MulOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Matx< double,2,1 > *)new cv::Matx< double,2,1 >((cv::Matx< double,2,1 > const &)*arg1,(cv::Matx< double,2,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_double_2_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_double_2_1__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< double,2,1 > *arg1 = 0 ;
cv::Matx< double,2,1 > *arg2 = 0 ;
cv::Matx_DivOp 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 ;
cv::Matx< double,2,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Matx_double_2_1",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_double_2_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_double_2_1" "', argument " "1"" of type '" "cv::Matx< double,2,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_double_2_1" "', argument " "1"" of type '" "cv::Matx< double,2,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< double,2,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_double_2_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Matx_double_2_1" "', argument " "2"" of type '" "cv::Matx< double,2,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_double_2_1" "', argument " "2"" of type '" "cv::Matx< double,2,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< double,2,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_DivOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Matx_double_2_1" "', argument " "3"" of type '" "cv::Matx_DivOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_double_2_1" "', argument " "3"" of type '" "cv::Matx_DivOp""'");
} else {
cv::Matx_DivOp * temp = reinterpret_cast< cv::Matx_DivOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Matx< double,2,1 > *)new cv::Matx< double,2,1 >((cv::Matx< double,2,1 > const &)*arg1,(cv::Matx< double,2,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_double_2_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_double_2_1__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< double,1,2 > *arg1 = 0 ;
cv::Matx_TOp arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
cv::Matx< double,2,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:new__Matx_double_2_1",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_double_1_2_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_double_2_1" "', argument " "1"" of type '" "cv::Matx< double,1,2 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_double_2_1" "', argument " "1"" of type '" "cv::Matx< double,1,2 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< double,1,2 > * >(argp1);
{
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__Matx_TOp, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Matx_double_2_1" "', argument " "2"" of type '" "cv::Matx_TOp""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_double_2_1" "', argument " "2"" of type '" "cv::Matx_TOp""'");
} else {
cv::Matx_TOp * temp = reinterpret_cast< cv::Matx_TOp * >(argp2);
arg2 = *temp;
if (SWIG_IsNewObj(res2)) delete temp;
}
}
result = (cv::Matx< double,2,1 > *)new cv::Matx< double,2,1 >((cv::Matx< double,1,2 > const &)*arg1,arg2);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_double_2_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_double_2_1_val_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< double,2,1 > *arg1 = (cv::Matx< double,2,1 > *) 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:_Matx_double_2_1_val_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_double_2_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_double_2_1_val_set" "', argument " "1"" of type '" "cv::Matx< double,2,1 > *""'");
}
arg1 = reinterpret_cast< cv::Matx< double,2,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_double_2_1_val_set" "', argument " "2"" of type '" "double [2*1]""'");
}
arg2 = reinterpret_cast< double * >(argp2);
{
if (arg2) {
size_t ii = 0;
for (; ii < (size_t)2*1; ++ii) *(double *)&arg1->val[ii] = *((double *)arg2 + ii);
} else {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""val""' of type '""double [2*1]""'");
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_double_2_1_val_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< double,2,1 > *arg1 = (cv::Matx< double,2,1 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
double *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:_Matx_double_2_1_val_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_double_2_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_double_2_1_val_get" "', argument " "1"" of type '" "cv::Matx< double,2,1 > *""'");
}
arg1 = reinterpret_cast< cv::Matx< double,2,1 > * >(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_new__Matx_double_2_1__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< cv::Matx< double,2,1 >::value_type,std::allocator< cv::Matx< double,2,1 >::value_type > > arg1 ;
PyObject * obj0 = 0 ;
cv::Matx< double,2,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__Matx_double_2_1",&obj0)) SWIG_fail;
{
std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
int res = swig::asptr(obj0, &ptr);
if (!SWIG_IsOK(res) || !ptr) {
SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new__Matx_double_2_1" "', argument " "1"" of type '" "std::vector< cv::Matx< double,2,1 >::value_type,std::allocator< cv::Matx< double,2,1 >::value_type > >""'");
}
arg1 = *ptr;
if (SWIG_IsNewObj(res)) delete ptr;
}
result = (cv::Matx< double,2,1 > *)new_cv_Matx_Sl_double_Sc_2_Sc_1_Sg___SWIG_6(arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_double_2_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_double_2_1(PyObject *self, PyObject *args) {
Py_ssize_t argc;
PyObject *argv[4] = {
0
};
Py_ssize_t ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = args ? PyObject_Length(args) : 0;
for (ii = 0; (ii < 3) && (ii < argc); 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_double, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_double_2_1__SWIG_0(self, args);
}
}
if (argc == 1) {
int _v;
int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_double_2_1__SWIG_6(self, args);
}
}
if (argc == 2) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_double_1_2_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__Matx_TOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_double_2_1__SWIG_5(self, args);
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_double_2_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_double_2_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_MulOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_double_2_1__SWIG_3(self, args);
}
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_double_2_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_double_2_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_DivOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_double_2_1__SWIG_4(self, args);
}
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_double_2_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_double_2_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_AddOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_double_2_1__SWIG_1(self, args);
}
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_double_2_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_double_2_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_SubOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_double_2_1__SWIG_2(self, args);
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new__Matx_double_2_1'.\n"
" Possible C/C++ prototypes are:\n"
" cv::Matx< double,2,1 >::Matx(double const *)\n"
" cv::Matx< double,2,1 >::Matx(cv::Matx< double,2,1 > const &,cv::Matx< double,2,1 > const &,cv::Matx_AddOp)\n"
" cv::Matx< double,2,1 >::Matx(cv::Matx< double,2,1 > const &,cv::Matx< double,2,1 > const &,cv::Matx_SubOp)\n"
" cv::Matx< double,2,1 >::Matx(cv::Matx< double,2,1 > const &,cv::Matx< double,2,1 > const &,cv::Matx_MulOp)\n"
" cv::Matx< double,2,1 >::Matx(cv::Matx< double,2,1 > const &,cv::Matx< double,2,1 > const &,cv::Matx_DivOp)\n"
" cv::Matx< double,2,1 >::Matx(cv::Matx< double,1,2 > const &,cv::Matx_TOp)\n"
" cv::Matx< double,2,1 >::Matx(std::vector< cv::Matx< double,2,1 >::value_type,std::allocator< cv::Matx< double,2,1 >::value_type > >)\n");
return 0;
}
SWIGINTERN PyObject *_wrap__Matx_double_2_1___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< double,2,1 > *arg1 = (cv::Matx< double,2,1 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
std::string result;
if (!PyArg_ParseTuple(args,(char *)"O:_Matx_double_2_1___str__",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_double_2_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_double_2_1___str__" "', argument " "1"" of type '" "cv::Matx< double,2,1 > *""'");
}
arg1 = reinterpret_cast< cv::Matx< double,2,1 > * >(argp1);
result = cv_Matx_Sl_double_Sc_2_Sc_1_Sg____str__(arg1);
resultobj = SWIG_From_std_string(static_cast< std::string >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete__Matx_double_2_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< double,2,1 > *arg1 = (cv::Matx< double,2,1 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete__Matx_double_2_1",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_double_2_1_t, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__Matx_double_2_1" "', argument " "1"" of type '" "cv::Matx< double,2,1 > *""'");
}
arg1 = reinterpret_cast< cv::Matx< double,2,1 > * >(argp1);
delete arg1;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_Matx_double_2_1_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_cv__MatxT_double_2_1_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_new__Vec_double_2__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
double *arg1 = (double *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
cv::Vec< double,2 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__Vec_double_2",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Vec_double_2" "', argument " "1"" of type '" "double const *""'");
}
arg1 = reinterpret_cast< double * >(argp1);
result = (cv::Vec< double,2 > *)new cv::Vec< double,2 >((double const *)arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__VecT_double_2_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Vec_double_2__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Vec< double,2 > *arg1 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
cv::Vec< double,2 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__Vec_double_2",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__VecT_double_2_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Vec_double_2" "', argument " "1"" of type '" "cv::Vec< double,2 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_double_2" "', argument " "1"" of type '" "cv::Vec< double,2 > const &""'");
}
arg1 = reinterpret_cast< cv::Vec< double,2 > * >(argp1);
result = (cv::Vec< double,2 > *)new cv::Vec< double,2 >((cv::Vec< double,2 > const &)*arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__VecT_double_2_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Vec_double_2_all(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
double arg1 ;
double val1 ;
int ecode1 = 0 ;
PyObject * obj0 = 0 ;
SwigValueWrapper< cv::Vec< double,2 > > result;
if (!PyArg_ParseTuple(args,(char *)"O:_Vec_double_2_all",&obj0)) SWIG_fail;
ecode1 = SWIG_AsVal_double(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_Vec_double_2_all" "', argument " "1"" of type '" "double""'");
}
arg1 = static_cast< double >(val1);
result = cv::Vec< double,2 >::SWIGTEMPLATEDISAMBIGUATOR all(arg1);
resultobj = SWIG_NewPointerObj((new cv::Vec< double,2 >(static_cast< const cv::Vec< double,2 >& >(result))), SWIGTYPE_p_cv__VecT_double_2_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Vec_double_2_mul(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Vec< double,2 > *arg1 = (cv::Vec< double,2 > *) 0 ;
cv::Vec< double,2 > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
SwigValueWrapper< cv::Vec< double,2 > > result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Vec_double_2_mul",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__VecT_double_2_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Vec_double_2_mul" "', argument " "1"" of type '" "cv::Vec< double,2 > const *""'");
}
arg1 = reinterpret_cast< cv::Vec< double,2 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__VecT_double_2_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Vec_double_2_mul" "', argument " "2"" of type '" "cv::Vec< double,2 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Vec_double_2_mul" "', argument " "2"" of type '" "cv::Vec< double,2 > const &""'");
}
arg2 = reinterpret_cast< cv::Vec< double,2 > * >(argp2);
result = ((cv::Vec< double,2 > const *)arg1)->mul((cv::Vec< double,2 > const &)*arg2);
resultobj = SWIG_NewPointerObj((new cv::Vec< double,2 >(static_cast< const cv::Vec< double,2 >& >(result))), SWIGTYPE_p_cv__VecT_double_2_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Vec_double_2___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Vec< double,2 > *arg1 = (cv::Vec< double,2 > *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
double *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:_Vec_double_2___call__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__VecT_double_2_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Vec_double_2___call__" "', argument " "1"" of type '" "cv::Vec< double,2 > const *""'");
}
arg1 = reinterpret_cast< cv::Vec< double,2 > * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_Vec_double_2___call__" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
result = (double *) &((cv::Vec< double,2 > const *)arg1)->operator ()(arg2);
resultobj = SWIG_From_double(static_cast< double >(*result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Vec_double_2__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< double,2,1 > *arg1 = 0 ;
cv::Matx< double,2,1 > *arg2 = 0 ;
cv::Matx_AddOp 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 ;
cv::Vec< double,2 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Vec_double_2",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_double_2_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Vec_double_2" "', argument " "1"" of type '" "cv::Matx< double,2,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_double_2" "', argument " "1"" of type '" "cv::Matx< double,2,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< double,2,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_double_2_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Vec_double_2" "', argument " "2"" of type '" "cv::Matx< double,2,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_double_2" "', argument " "2"" of type '" "cv::Matx< double,2,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< double,2,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_AddOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Vec_double_2" "', argument " "3"" of type '" "cv::Matx_AddOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_double_2" "', argument " "3"" of type '" "cv::Matx_AddOp""'");
} else {
cv::Matx_AddOp * temp = reinterpret_cast< cv::Matx_AddOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Vec< double,2 > *)new cv::Vec< double,2 >((cv::Matx< double,2,1 > const &)*arg1,(cv::Matx< double,2,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__VecT_double_2_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Vec_double_2__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< double,2,1 > *arg1 = 0 ;
cv::Matx< double,2,1 > *arg2 = 0 ;
cv::Matx_SubOp 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 ;
cv::Vec< double,2 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Vec_double_2",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_double_2_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Vec_double_2" "', argument " "1"" of type '" "cv::Matx< double,2,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_double_2" "', argument " "1"" of type '" "cv::Matx< double,2,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< double,2,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_double_2_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Vec_double_2" "', argument " "2"" of type '" "cv::Matx< double,2,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_double_2" "', argument " "2"" of type '" "cv::Matx< double,2,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< double,2,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_SubOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Vec_double_2" "', argument " "3"" of type '" "cv::Matx_SubOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_double_2" "', argument " "3"" of type '" "cv::Matx_SubOp""'");
} else {
cv::Matx_SubOp * temp = reinterpret_cast< cv::Matx_SubOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Vec< double,2 > *)new cv::Vec< double,2 >((cv::Matx< double,2,1 > const &)*arg1,(cv::Matx< double,2,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__VecT_double_2_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Vec_double_2__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< cv::Vec< double,2 >::value_type,std::allocator< cv::Vec< double,2 >::value_type > > arg1 ;
PyObject * obj0 = 0 ;
cv::Vec< double,2 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__Vec_double_2",&obj0)) SWIG_fail;
{
std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
int res = swig::asptr(obj0, &ptr);
if (!SWIG_IsOK(res) || !ptr) {
SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new__Vec_double_2" "', argument " "1"" of type '" "std::vector< cv::Vec< double,2 >::value_type,std::allocator< cv::Vec< double,2 >::value_type > >""'");
}
arg1 = *ptr;
if (SWIG_IsNewObj(res)) delete ptr;
}
result = (cv::Vec< double,2 > *)new_cv_Vec_Sl_double_Sc_2_Sg___SWIG_4(arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__VecT_double_2_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Vec_double_2(PyObject *self, PyObject *args) {
Py_ssize_t argc;
PyObject *argv[4] = {
0
};
Py_ssize_t ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = args ? PyObject_Length(args) : 0;
for (ii = 0; (ii < 3) && (ii < argc); 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_double, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Vec_double_2__SWIG_0(self, args);
}
}
if (argc == 1) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__VecT_double_2_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Vec_double_2__SWIG_1(self, args);
}
}
if (argc == 1) {
int _v;
int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Vec_double_2__SWIG_4(self, args);
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_double_2_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_double_2_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_SubOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Vec_double_2__SWIG_3(self, args);
}
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_double_2_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_double_2_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_AddOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Vec_double_2__SWIG_2(self, args);
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new__Vec_double_2'.\n"
" Possible C/C++ prototypes are:\n"
" cv::Vec< double,2 >::Vec(double const *)\n"
" cv::Vec< double,2 >::Vec(cv::Vec< double,2 > const &)\n"
" cv::Vec< double,2 >::Vec(cv::Matx< double,2,1 > const &,cv::Matx< double,2,1 > const &,cv::Matx_AddOp)\n"
" cv::Vec< double,2 >::Vec(cv::Matx< double,2,1 > const &,cv::Matx< double,2,1 > const &,cv::Matx_SubOp)\n"
" cv::Vec< double,2 >::Vec(std::vector< cv::Vec< double,2 >::value_type,std::allocator< cv::Vec< double,2 >::value_type > >)\n");
return 0;
}
SWIGINTERN PyObject *_wrap__Vec_double_2___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Vec< double,2 > *arg1 = (cv::Vec< double,2 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
std::string result;
if (!PyArg_ParseTuple(args,(char *)"O:_Vec_double_2___str__",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__VecT_double_2_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Vec_double_2___str__" "', argument " "1"" of type '" "cv::Vec< double,2 > *""'");
}
arg1 = reinterpret_cast< cv::Vec< double,2 > * >(argp1);
result = cv_Vec_Sl_double_Sc_2_Sg____str__(arg1);
resultobj = SWIG_From_std_string(static_cast< std::string >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete__Vec_double_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Vec< double,2 > *arg1 = (cv::Vec< double,2 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete__Vec_double_2",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__VecT_double_2_t, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__Vec_double_2" "', argument " "1"" of type '" "cv::Vec< double,2 > *""'");
}
arg1 = reinterpret_cast< cv::Vec< double,2 > * >(argp1);
delete arg1;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_Vec_double_2_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_cv__VecT_double_2_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_new__DataType_Vec_double_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::DataType< cv::Vec< double,2 > > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new__DataType_Vec_double_2")) SWIG_fail;
result = (cv::DataType< cv::Vec< double,2 > > *)new cv::DataType< cv::Vec< double,2 > >();
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__DataTypeT_cv__VecT_double_2_t_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete__DataType_Vec_double_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::DataType< cv::Vec< double,2 > > *arg1 = (cv::DataType< cv::Vec< double,2 > > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete__DataType_Vec_double_2",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__DataTypeT_cv__VecT_double_2_t_t, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__DataType_Vec_double_2" "', argument " "1"" of type '" "cv::DataType< cv::Vec< double,2 > > *""'");
}
arg1 = reinterpret_cast< cv::DataType< cv::Vec< double,2 > > * >(argp1);
delete arg1;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_DataType_Vec_double_2_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_cv__DataTypeT_cv__VecT_double_2_t_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_new__Matx_double_3_1__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
double *arg1 = (double *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
cv::Matx< double,3,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__Matx_double_3_1",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_double_3_1" "', argument " "1"" of type '" "double const *""'");
}
arg1 = reinterpret_cast< double * >(argp1);
result = (cv::Matx< double,3,1 > *)new cv::Matx< double,3,1 >((double const *)arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_double_3_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_double_3_1_all(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
double arg1 ;
double val1 ;
int ecode1 = 0 ;
PyObject * obj0 = 0 ;
SwigValueWrapper< cv::Matx< double,3,1 > > result;
if (!PyArg_ParseTuple(args,(char *)"O:_Matx_double_3_1_all",&obj0)) SWIG_fail;
ecode1 = SWIG_AsVal_double(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_Matx_double_3_1_all" "', argument " "1"" of type '" "double""'");
}
arg1 = static_cast< double >(val1);
result = cv::Matx< double,3,1 >::SWIGTEMPLATEDISAMBIGUATOR all(arg1);
resultobj = SWIG_NewPointerObj((new cv::Matx< double,3,1 >(static_cast< const cv::Matx< double,3,1 >& >(result))), SWIGTYPE_p_cv__MatxT_double_3_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_double_3_1_zeros(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
SwigValueWrapper< cv::Matx< double,3,1 > > result;
if (!PyArg_ParseTuple(args,(char *)":_Matx_double_3_1_zeros")) SWIG_fail;
result = cv::Matx< double,3,1 >::SWIGTEMPLATEDISAMBIGUATOR zeros();
resultobj = SWIG_NewPointerObj((new cv::Matx< double,3,1 >(static_cast< const cv::Matx< double,3,1 >& >(result))), SWIGTYPE_p_cv__MatxT_double_3_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_double_3_1_ones(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
SwigValueWrapper< cv::Matx< double,3,1 > > result;
if (!PyArg_ParseTuple(args,(char *)":_Matx_double_3_1_ones")) SWIG_fail;
result = cv::Matx< double,3,1 >::SWIGTEMPLATEDISAMBIGUATOR ones();
resultobj = SWIG_NewPointerObj((new cv::Matx< double,3,1 >(static_cast< const cv::Matx< double,3,1 >& >(result))), SWIGTYPE_p_cv__MatxT_double_3_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_double_3_1_eye(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
SwigValueWrapper< cv::Matx< double,3,1 > > result;
if (!PyArg_ParseTuple(args,(char *)":_Matx_double_3_1_eye")) SWIG_fail;
result = cv::Matx< double,3,1 >::SWIGTEMPLATEDISAMBIGUATOR eye();
resultobj = SWIG_NewPointerObj((new cv::Matx< double,3,1 >(static_cast< const cv::Matx< double,3,1 >& >(result))), SWIGTYPE_p_cv__MatxT_double_3_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_double_3_1_randu(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 ;
SwigValueWrapper< cv::Matx< double,3,1 > > result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_double_3_1_randu",&obj0,&obj1)) SWIG_fail;
ecode1 = SWIG_AsVal_double(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_Matx_double_3_1_randu" "', 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 '" "_Matx_double_3_1_randu" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
result = cv::Matx< double,3,1 >::SWIGTEMPLATEDISAMBIGUATOR randu(arg1,arg2);
resultobj = SWIG_NewPointerObj((new cv::Matx< double,3,1 >(static_cast< const cv::Matx< double,3,1 >& >(result))), SWIGTYPE_p_cv__MatxT_double_3_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_double_3_1_randn(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 ;
SwigValueWrapper< cv::Matx< double,3,1 > > result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_double_3_1_randn",&obj0,&obj1)) SWIG_fail;
ecode1 = SWIG_AsVal_double(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_Matx_double_3_1_randn" "', 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 '" "_Matx_double_3_1_randn" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
result = cv::Matx< double,3,1 >::SWIGTEMPLATEDISAMBIGUATOR randn(arg1,arg2);
resultobj = SWIG_NewPointerObj((new cv::Matx< double,3,1 >(static_cast< const cv::Matx< double,3,1 >& >(result))), SWIGTYPE_p_cv__MatxT_double_3_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_double_3_1_dot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< double,3,1 > *arg1 = (cv::Matx< double,3,1 > *) 0 ;
cv::Matx< double,3,1 > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
double result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_double_3_1_dot",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_double_3_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_double_3_1_dot" "', argument " "1"" of type '" "cv::Matx< double,3,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< double,3,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_double_3_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_double_3_1_dot" "', argument " "2"" of type '" "cv::Matx< double,3,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Matx_double_3_1_dot" "', argument " "2"" of type '" "cv::Matx< double,3,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< double,3,1 > * >(argp2);
result = (double)((cv::Matx< double,3,1 > const *)arg1)->dot((cv::Matx< double,3,1 > const &)*arg2);
resultobj = SWIG_From_double(static_cast< double >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_double_3_1_ddot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< double,3,1 > *arg1 = (cv::Matx< double,3,1 > *) 0 ;
cv::Matx< double,3,1 > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
double result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_double_3_1_ddot",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_double_3_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_double_3_1_ddot" "', argument " "1"" of type '" "cv::Matx< double,3,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< double,3,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_double_3_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_double_3_1_ddot" "', argument " "2"" of type '" "cv::Matx< double,3,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Matx_double_3_1_ddot" "', argument " "2"" of type '" "cv::Matx< double,3,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< double,3,1 > * >(argp2);
result = (double)((cv::Matx< double,3,1 > const *)arg1)->ddot((cv::Matx< double,3,1 > const &)*arg2);
resultobj = SWIG_From_double(static_cast< double >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_double_3_1_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< double,3,1 > *arg1 = (cv::Matx< double,3,1 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
SwigValueWrapper< cv::Matx< double,1,3 > > result;
if (!PyArg_ParseTuple(args,(char *)"O:_Matx_double_3_1_t",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_double_3_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_double_3_1_t" "', argument " "1"" of type '" "cv::Matx< double,3,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< double,3,1 > * >(argp1);
result = ((cv::Matx< double,3,1 > const *)arg1)->t();
resultobj = SWIG_NewPointerObj((new cv::Matx< double,1,3 >(static_cast< const cv::Matx< double,1,3 >& >(result))), SWIGTYPE_p_cv__MatxT_double_1_3_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_double_3_1_mul(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< double,3,1 > *arg1 = (cv::Matx< double,3,1 > *) 0 ;
cv::Matx< double,3,1 > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
SwigValueWrapper< cv::Matx< double,3,1 > > result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_double_3_1_mul",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_double_3_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_double_3_1_mul" "', argument " "1"" of type '" "cv::Matx< double,3,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< double,3,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_double_3_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_double_3_1_mul" "', argument " "2"" of type '" "cv::Matx< double,3,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Matx_double_3_1_mul" "', argument " "2"" of type '" "cv::Matx< double,3,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< double,3,1 > * >(argp2);
result = ((cv::Matx< double,3,1 > const *)arg1)->mul((cv::Matx< double,3,1 > const &)*arg2);
resultobj = SWIG_NewPointerObj((new cv::Matx< double,3,1 >(static_cast< const cv::Matx< double,3,1 >& >(result))), SWIGTYPE_p_cv__MatxT_double_3_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_double_3_1_div(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< double,3,1 > *arg1 = (cv::Matx< double,3,1 > *) 0 ;
cv::Matx< double,3,1 > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
SwigValueWrapper< cv::Matx< double,3,1 > > result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_double_3_1_div",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_double_3_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_double_3_1_div" "', argument " "1"" of type '" "cv::Matx< double,3,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< double,3,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_double_3_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_double_3_1_div" "', argument " "2"" of type '" "cv::Matx< double,3,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Matx_double_3_1_div" "', argument " "2"" of type '" "cv::Matx< double,3,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< double,3,1 > * >(argp2);
result = ((cv::Matx< double,3,1 > const *)arg1)->div((cv::Matx< double,3,1 > const &)*arg2);
resultobj = SWIG_NewPointerObj((new cv::Matx< double,3,1 >(static_cast< const cv::Matx< double,3,1 >& >(result))), SWIGTYPE_p_cv__MatxT_double_3_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_double_3_1___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< double,3,1 > *arg1 = (cv::Matx< double,3,1 > *) 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 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:_Matx_double_3_1___call__",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_double_3_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_double_3_1___call__" "', argument " "1"" of type '" "cv::Matx< double,3,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< double,3,1 > * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_Matx_double_3_1___call__" "', 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 '" "_Matx_double_3_1___call__" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
result = (double *) &((cv::Matx< double,3,1 > const *)arg1)->operator ()(arg2,arg3);
resultobj = SWIG_From_double(static_cast< double >(*result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_double_3_1__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< double,3,1 > *arg1 = 0 ;
cv::Matx< double,3,1 > *arg2 = 0 ;
cv::Matx_AddOp 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 ;
cv::Matx< double,3,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Matx_double_3_1",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_double_3_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_double_3_1" "', argument " "1"" of type '" "cv::Matx< double,3,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_double_3_1" "', argument " "1"" of type '" "cv::Matx< double,3,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< double,3,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_double_3_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Matx_double_3_1" "', argument " "2"" of type '" "cv::Matx< double,3,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_double_3_1" "', argument " "2"" of type '" "cv::Matx< double,3,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< double,3,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_AddOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Matx_double_3_1" "', argument " "3"" of type '" "cv::Matx_AddOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_double_3_1" "', argument " "3"" of type '" "cv::Matx_AddOp""'");
} else {
cv::Matx_AddOp * temp = reinterpret_cast< cv::Matx_AddOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Matx< double,3,1 > *)new cv::Matx< double,3,1 >((cv::Matx< double,3,1 > const &)*arg1,(cv::Matx< double,3,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_double_3_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_double_3_1__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< double,3,1 > *arg1 = 0 ;
cv::Matx< double,3,1 > *arg2 = 0 ;
cv::Matx_SubOp 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 ;
cv::Matx< double,3,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Matx_double_3_1",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_double_3_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_double_3_1" "', argument " "1"" of type '" "cv::Matx< double,3,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_double_3_1" "', argument " "1"" of type '" "cv::Matx< double,3,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< double,3,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_double_3_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Matx_double_3_1" "', argument " "2"" of type '" "cv::Matx< double,3,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_double_3_1" "', argument " "2"" of type '" "cv::Matx< double,3,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< double,3,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_SubOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Matx_double_3_1" "', argument " "3"" of type '" "cv::Matx_SubOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_double_3_1" "', argument " "3"" of type '" "cv::Matx_SubOp""'");
} else {
cv::Matx_SubOp * temp = reinterpret_cast< cv::Matx_SubOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Matx< double,3,1 > *)new cv::Matx< double,3,1 >((cv::Matx< double,3,1 > const &)*arg1,(cv::Matx< double,3,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_double_3_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_double_3_1__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< double,3,1 > *arg1 = 0 ;
cv::Matx< double,3,1 > *arg2 = 0 ;
cv::Matx_MulOp 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 ;
cv::Matx< double,3,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Matx_double_3_1",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_double_3_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_double_3_1" "', argument " "1"" of type '" "cv::Matx< double,3,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_double_3_1" "', argument " "1"" of type '" "cv::Matx< double,3,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< double,3,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_double_3_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Matx_double_3_1" "', argument " "2"" of type '" "cv::Matx< double,3,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_double_3_1" "', argument " "2"" of type '" "cv::Matx< double,3,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< double,3,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_MulOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Matx_double_3_1" "', argument " "3"" of type '" "cv::Matx_MulOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_double_3_1" "', argument " "3"" of type '" "cv::Matx_MulOp""'");
} else {
cv::Matx_MulOp * temp = reinterpret_cast< cv::Matx_MulOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Matx< double,3,1 > *)new cv::Matx< double,3,1 >((cv::Matx< double,3,1 > const &)*arg1,(cv::Matx< double,3,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_double_3_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_double_3_1__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< double,3,1 > *arg1 = 0 ;
cv::Matx< double,3,1 > *arg2 = 0 ;
cv::Matx_DivOp 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 ;
cv::Matx< double,3,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Matx_double_3_1",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_double_3_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_double_3_1" "', argument " "1"" of type '" "cv::Matx< double,3,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_double_3_1" "', argument " "1"" of type '" "cv::Matx< double,3,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< double,3,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_double_3_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Matx_double_3_1" "', argument " "2"" of type '" "cv::Matx< double,3,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_double_3_1" "', argument " "2"" of type '" "cv::Matx< double,3,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< double,3,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_DivOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Matx_double_3_1" "', argument " "3"" of type '" "cv::Matx_DivOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_double_3_1" "', argument " "3"" of type '" "cv::Matx_DivOp""'");
} else {
cv::Matx_DivOp * temp = reinterpret_cast< cv::Matx_DivOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Matx< double,3,1 > *)new cv::Matx< double,3,1 >((cv::Matx< double,3,1 > const &)*arg1,(cv::Matx< double,3,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_double_3_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_double_3_1__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< double,1,3 > *arg1 = 0 ;
cv::Matx_TOp arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
cv::Matx< double,3,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:new__Matx_double_3_1",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_double_1_3_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_double_3_1" "', argument " "1"" of type '" "cv::Matx< double,1,3 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_double_3_1" "', argument " "1"" of type '" "cv::Matx< double,1,3 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< double,1,3 > * >(argp1);
{
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__Matx_TOp, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Matx_double_3_1" "', argument " "2"" of type '" "cv::Matx_TOp""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_double_3_1" "', argument " "2"" of type '" "cv::Matx_TOp""'");
} else {
cv::Matx_TOp * temp = reinterpret_cast< cv::Matx_TOp * >(argp2);
arg2 = *temp;
if (SWIG_IsNewObj(res2)) delete temp;
}
}
result = (cv::Matx< double,3,1 > *)new cv::Matx< double,3,1 >((cv::Matx< double,1,3 > const &)*arg1,arg2);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_double_3_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_double_3_1_val_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< double,3,1 > *arg1 = (cv::Matx< double,3,1 > *) 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:_Matx_double_3_1_val_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_double_3_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_double_3_1_val_set" "', argument " "1"" of type '" "cv::Matx< double,3,1 > *""'");
}
arg1 = reinterpret_cast< cv::Matx< double,3,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_double_3_1_val_set" "', argument " "2"" of type '" "double [3*1]""'");
}
arg2 = reinterpret_cast< double * >(argp2);
{
if (arg2) {
size_t ii = 0;
for (; ii < (size_t)3*1; ++ii) *(double *)&arg1->val[ii] = *((double *)arg2 + ii);
} else {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""val""' of type '""double [3*1]""'");
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_double_3_1_val_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< double,3,1 > *arg1 = (cv::Matx< double,3,1 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
double *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:_Matx_double_3_1_val_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_double_3_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_double_3_1_val_get" "', argument " "1"" of type '" "cv::Matx< double,3,1 > *""'");
}
arg1 = reinterpret_cast< cv::Matx< double,3,1 > * >(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_new__Matx_double_3_1__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< cv::Matx< double,3,1 >::value_type,std::allocator< cv::Matx< double,3,1 >::value_type > > arg1 ;
PyObject * obj0 = 0 ;
cv::Matx< double,3,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__Matx_double_3_1",&obj0)) SWIG_fail;
{
std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
int res = swig::asptr(obj0, &ptr);
if (!SWIG_IsOK(res) || !ptr) {
SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new__Matx_double_3_1" "', argument " "1"" of type '" "std::vector< cv::Matx< double,3,1 >::value_type,std::allocator< cv::Matx< double,3,1 >::value_type > >""'");
}
arg1 = *ptr;
if (SWIG_IsNewObj(res)) delete ptr;
}
result = (cv::Matx< double,3,1 > *)new_cv_Matx_Sl_double_Sc_3_Sc_1_Sg___SWIG_6(arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_double_3_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_double_3_1(PyObject *self, PyObject *args) {
Py_ssize_t argc;
PyObject *argv[4] = {
0
};
Py_ssize_t ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = args ? PyObject_Length(args) : 0;
for (ii = 0; (ii < 3) && (ii < argc); 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_double, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_double_3_1__SWIG_0(self, args);
}
}
if (argc == 1) {
int _v;
int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_double_3_1__SWIG_6(self, args);
}
}
if (argc == 2) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_double_1_3_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__Matx_TOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_double_3_1__SWIG_5(self, args);
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_double_3_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_double_3_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_MulOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_double_3_1__SWIG_3(self, args);
}
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_double_3_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_double_3_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_DivOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_double_3_1__SWIG_4(self, args);
}
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_double_3_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_double_3_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_AddOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_double_3_1__SWIG_1(self, args);
}
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_double_3_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_double_3_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_SubOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_double_3_1__SWIG_2(self, args);
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new__Matx_double_3_1'.\n"
" Possible C/C++ prototypes are:\n"
" cv::Matx< double,3,1 >::Matx(double const *)\n"
" cv::Matx< double,3,1 >::Matx(cv::Matx< double,3,1 > const &,cv::Matx< double,3,1 > const &,cv::Matx_AddOp)\n"
" cv::Matx< double,3,1 >::Matx(cv::Matx< double,3,1 > const &,cv::Matx< double,3,1 > const &,cv::Matx_SubOp)\n"
" cv::Matx< double,3,1 >::Matx(cv::Matx< double,3,1 > const &,cv::Matx< double,3,1 > const &,cv::Matx_MulOp)\n"
" cv::Matx< double,3,1 >::Matx(cv::Matx< double,3,1 > const &,cv::Matx< double,3,1 > const &,cv::Matx_DivOp)\n"
" cv::Matx< double,3,1 >::Matx(cv::Matx< double,1,3 > const &,cv::Matx_TOp)\n"
" cv::Matx< double,3,1 >::Matx(std::vector< cv::Matx< double,3,1 >::value_type,std::allocator< cv::Matx< double,3,1 >::value_type > >)\n");
return 0;
}
SWIGINTERN PyObject *_wrap__Matx_double_3_1___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< double,3,1 > *arg1 = (cv::Matx< double,3,1 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
std::string result;
if (!PyArg_ParseTuple(args,(char *)"O:_Matx_double_3_1___str__",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_double_3_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_double_3_1___str__" "', argument " "1"" of type '" "cv::Matx< double,3,1 > *""'");
}
arg1 = reinterpret_cast< cv::Matx< double,3,1 > * >(argp1);
result = cv_Matx_Sl_double_Sc_3_Sc_1_Sg____str__(arg1);
resultobj = SWIG_From_std_string(static_cast< std::string >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete__Matx_double_3_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< double,3,1 > *arg1 = (cv::Matx< double,3,1 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete__Matx_double_3_1",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_double_3_1_t, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__Matx_double_3_1" "', argument " "1"" of type '" "cv::Matx< double,3,1 > *""'");
}
arg1 = reinterpret_cast< cv::Matx< double,3,1 > * >(argp1);
delete arg1;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_Matx_double_3_1_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_cv__MatxT_double_3_1_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_new__Vec_double_3__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
double *arg1 = (double *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
cv::Vec< double,3 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__Vec_double_3",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Vec_double_3" "', argument " "1"" of type '" "double const *""'");
}
arg1 = reinterpret_cast< double * >(argp1);
result = (cv::Vec< double,3 > *)new cv::Vec< double,3 >((double const *)arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__VecT_double_3_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Vec_double_3__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Vec< double,3 > *arg1 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
cv::Vec< double,3 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__Vec_double_3",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__VecT_double_3_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Vec_double_3" "', argument " "1"" of type '" "cv::Vec< double,3 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_double_3" "', argument " "1"" of type '" "cv::Vec< double,3 > const &""'");
}
arg1 = reinterpret_cast< cv::Vec< double,3 > * >(argp1);
result = (cv::Vec< double,3 > *)new cv::Vec< double,3 >((cv::Vec< double,3 > const &)*arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__VecT_double_3_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Vec_double_3_all(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
double arg1 ;
double val1 ;
int ecode1 = 0 ;
PyObject * obj0 = 0 ;
SwigValueWrapper< cv::Vec< double,3 > > result;
if (!PyArg_ParseTuple(args,(char *)"O:_Vec_double_3_all",&obj0)) SWIG_fail;
ecode1 = SWIG_AsVal_double(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_Vec_double_3_all" "', argument " "1"" of type '" "double""'");
}
arg1 = static_cast< double >(val1);
result = cv::Vec< double,3 >::SWIGTEMPLATEDISAMBIGUATOR all(arg1);
resultobj = SWIG_NewPointerObj((new cv::Vec< double,3 >(static_cast< const cv::Vec< double,3 >& >(result))), SWIGTYPE_p_cv__VecT_double_3_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Vec_double_3_mul(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Vec< double,3 > *arg1 = (cv::Vec< double,3 > *) 0 ;
cv::Vec< double,3 > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
SwigValueWrapper< cv::Vec< double,3 > > result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Vec_double_3_mul",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__VecT_double_3_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Vec_double_3_mul" "', argument " "1"" of type '" "cv::Vec< double,3 > const *""'");
}
arg1 = reinterpret_cast< cv::Vec< double,3 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__VecT_double_3_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Vec_double_3_mul" "', argument " "2"" of type '" "cv::Vec< double,3 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Vec_double_3_mul" "', argument " "2"" of type '" "cv::Vec< double,3 > const &""'");
}
arg2 = reinterpret_cast< cv::Vec< double,3 > * >(argp2);
result = ((cv::Vec< double,3 > const *)arg1)->mul((cv::Vec< double,3 > const &)*arg2);
resultobj = SWIG_NewPointerObj((new cv::Vec< double,3 >(static_cast< const cv::Vec< double,3 >& >(result))), SWIGTYPE_p_cv__VecT_double_3_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Vec_double_3___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Vec< double,3 > *arg1 = (cv::Vec< double,3 > *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
double *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:_Vec_double_3___call__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__VecT_double_3_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Vec_double_3___call__" "', argument " "1"" of type '" "cv::Vec< double,3 > const *""'");
}
arg1 = reinterpret_cast< cv::Vec< double,3 > * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_Vec_double_3___call__" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
result = (double *) &((cv::Vec< double,3 > const *)arg1)->operator ()(arg2);
resultobj = SWIG_From_double(static_cast< double >(*result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Vec_double_3__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< double,3,1 > *arg1 = 0 ;
cv::Matx< double,3,1 > *arg2 = 0 ;
cv::Matx_AddOp 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 ;
cv::Vec< double,3 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Vec_double_3",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_double_3_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Vec_double_3" "', argument " "1"" of type '" "cv::Matx< double,3,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_double_3" "', argument " "1"" of type '" "cv::Matx< double,3,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< double,3,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_double_3_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Vec_double_3" "', argument " "2"" of type '" "cv::Matx< double,3,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_double_3" "', argument " "2"" of type '" "cv::Matx< double,3,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< double,3,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_AddOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Vec_double_3" "', argument " "3"" of type '" "cv::Matx_AddOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_double_3" "', argument " "3"" of type '" "cv::Matx_AddOp""'");
} else {
cv::Matx_AddOp * temp = reinterpret_cast< cv::Matx_AddOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Vec< double,3 > *)new cv::Vec< double,3 >((cv::Matx< double,3,1 > const &)*arg1,(cv::Matx< double,3,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__VecT_double_3_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Vec_double_3__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< double,3,1 > *arg1 = 0 ;
cv::Matx< double,3,1 > *arg2 = 0 ;
cv::Matx_SubOp 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 ;
cv::Vec< double,3 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Vec_double_3",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_double_3_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Vec_double_3" "', argument " "1"" of type '" "cv::Matx< double,3,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_double_3" "', argument " "1"" of type '" "cv::Matx< double,3,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< double,3,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_double_3_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Vec_double_3" "', argument " "2"" of type '" "cv::Matx< double,3,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_double_3" "', argument " "2"" of type '" "cv::Matx< double,3,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< double,3,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_SubOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Vec_double_3" "', argument " "3"" of type '" "cv::Matx_SubOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_double_3" "', argument " "3"" of type '" "cv::Matx_SubOp""'");
} else {
cv::Matx_SubOp * temp = reinterpret_cast< cv::Matx_SubOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Vec< double,3 > *)new cv::Vec< double,3 >((cv::Matx< double,3,1 > const &)*arg1,(cv::Matx< double,3,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__VecT_double_3_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Vec_double_3__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< cv::Vec< double,3 >::value_type,std::allocator< cv::Vec< double,3 >::value_type > > arg1 ;
PyObject * obj0 = 0 ;
cv::Vec< double,3 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__Vec_double_3",&obj0)) SWIG_fail;
{
std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
int res = swig::asptr(obj0, &ptr);
if (!SWIG_IsOK(res) || !ptr) {
SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new__Vec_double_3" "', argument " "1"" of type '" "std::vector< cv::Vec< double,3 >::value_type,std::allocator< cv::Vec< double,3 >::value_type > >""'");
}
arg1 = *ptr;
if (SWIG_IsNewObj(res)) delete ptr;
}
result = (cv::Vec< double,3 > *)new_cv_Vec_Sl_double_Sc_3_Sg___SWIG_4(arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__VecT_double_3_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Vec_double_3(PyObject *self, PyObject *args) {
Py_ssize_t argc;
PyObject *argv[4] = {
0
};
Py_ssize_t ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = args ? PyObject_Length(args) : 0;
for (ii = 0; (ii < 3) && (ii < argc); 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_double, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Vec_double_3__SWIG_0(self, args);
}
}
if (argc == 1) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__VecT_double_3_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Vec_double_3__SWIG_1(self, args);
}
}
if (argc == 1) {
int _v;
int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Vec_double_3__SWIG_4(self, args);
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_double_3_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_double_3_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_SubOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Vec_double_3__SWIG_3(self, args);
}
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_double_3_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_double_3_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_AddOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Vec_double_3__SWIG_2(self, args);
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new__Vec_double_3'.\n"
" Possible C/C++ prototypes are:\n"
" cv::Vec< double,3 >::Vec(double const *)\n"
" cv::Vec< double,3 >::Vec(cv::Vec< double,3 > const &)\n"
" cv::Vec< double,3 >::Vec(cv::Matx< double,3,1 > const &,cv::Matx< double,3,1 > const &,cv::Matx_AddOp)\n"
" cv::Vec< double,3 >::Vec(cv::Matx< double,3,1 > const &,cv::Matx< double,3,1 > const &,cv::Matx_SubOp)\n"
" cv::Vec< double,3 >::Vec(std::vector< cv::Vec< double,3 >::value_type,std::allocator< cv::Vec< double,3 >::value_type > >)\n");
return 0;
}
SWIGINTERN PyObject *_wrap__Vec_double_3___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Vec< double,3 > *arg1 = (cv::Vec< double,3 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
std::string result;
if (!PyArg_ParseTuple(args,(char *)"O:_Vec_double_3___str__",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__VecT_double_3_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Vec_double_3___str__" "', argument " "1"" of type '" "cv::Vec< double,3 > *""'");
}
arg1 = reinterpret_cast< cv::Vec< double,3 > * >(argp1);
result = cv_Vec_Sl_double_Sc_3_Sg____str__(arg1);
resultobj = SWIG_From_std_string(static_cast< std::string >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete__Vec_double_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Vec< double,3 > *arg1 = (cv::Vec< double,3 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete__Vec_double_3",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__VecT_double_3_t, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__Vec_double_3" "', argument " "1"" of type '" "cv::Vec< double,3 > *""'");
}
arg1 = reinterpret_cast< cv::Vec< double,3 > * >(argp1);
delete arg1;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_Vec_double_3_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_cv__VecT_double_3_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_new__DataType_Vec_double_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::DataType< cv::Vec< double,3 > > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new__DataType_Vec_double_3")) SWIG_fail;
result = (cv::DataType< cv::Vec< double,3 > > *)new cv::DataType< cv::Vec< double,3 > >();
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__DataTypeT_cv__VecT_double_3_t_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete__DataType_Vec_double_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::DataType< cv::Vec< double,3 > > *arg1 = (cv::DataType< cv::Vec< double,3 > > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete__DataType_Vec_double_3",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__DataTypeT_cv__VecT_double_3_t_t, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__DataType_Vec_double_3" "', argument " "1"" of type '" "cv::DataType< cv::Vec< double,3 > > *""'");
}
arg1 = reinterpret_cast< cv::DataType< cv::Vec< double,3 > > * >(argp1);
delete arg1;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_DataType_Vec_double_3_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_cv__DataTypeT_cv__VecT_double_3_t_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_new__Matx_double_4_1__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
double *arg1 = (double *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
cv::Matx< double,4,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__Matx_double_4_1",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_double_4_1" "', argument " "1"" of type '" "double const *""'");
}
arg1 = reinterpret_cast< double * >(argp1);
result = (cv::Matx< double,4,1 > *)new cv::Matx< double,4,1 >((double const *)arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_double_4_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_double_4_1_all(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
double arg1 ;
double val1 ;
int ecode1 = 0 ;
PyObject * obj0 = 0 ;
SwigValueWrapper< cv::Matx< double,4,1 > > result;
if (!PyArg_ParseTuple(args,(char *)"O:_Matx_double_4_1_all",&obj0)) SWIG_fail;
ecode1 = SWIG_AsVal_double(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_Matx_double_4_1_all" "', argument " "1"" of type '" "double""'");
}
arg1 = static_cast< double >(val1);
result = cv::Matx< double,4,1 >::SWIGTEMPLATEDISAMBIGUATOR all(arg1);
resultobj = SWIG_NewPointerObj((new cv::Matx< double,4,1 >(static_cast< const cv::Matx< double,4,1 >& >(result))), SWIGTYPE_p_cv__MatxT_double_4_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_double_4_1_zeros(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
SwigValueWrapper< cv::Matx< double,4,1 > > result;
if (!PyArg_ParseTuple(args,(char *)":_Matx_double_4_1_zeros")) SWIG_fail;
result = cv::Matx< double,4,1 >::SWIGTEMPLATEDISAMBIGUATOR zeros();
resultobj = SWIG_NewPointerObj((new cv::Matx< double,4,1 >(static_cast< const cv::Matx< double,4,1 >& >(result))), SWIGTYPE_p_cv__MatxT_double_4_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_double_4_1_ones(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
SwigValueWrapper< cv::Matx< double,4,1 > > result;
if (!PyArg_ParseTuple(args,(char *)":_Matx_double_4_1_ones")) SWIG_fail;
result = cv::Matx< double,4,1 >::SWIGTEMPLATEDISAMBIGUATOR ones();
resultobj = SWIG_NewPointerObj((new cv::Matx< double,4,1 >(static_cast< const cv::Matx< double,4,1 >& >(result))), SWIGTYPE_p_cv__MatxT_double_4_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_double_4_1_eye(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
SwigValueWrapper< cv::Matx< double,4,1 > > result;
if (!PyArg_ParseTuple(args,(char *)":_Matx_double_4_1_eye")) SWIG_fail;
result = cv::Matx< double,4,1 >::SWIGTEMPLATEDISAMBIGUATOR eye();
resultobj = SWIG_NewPointerObj((new cv::Matx< double,4,1 >(static_cast< const cv::Matx< double,4,1 >& >(result))), SWIGTYPE_p_cv__MatxT_double_4_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_double_4_1_randu(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 ;
SwigValueWrapper< cv::Matx< double,4,1 > > result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_double_4_1_randu",&obj0,&obj1)) SWIG_fail;
ecode1 = SWIG_AsVal_double(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_Matx_double_4_1_randu" "', 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 '" "_Matx_double_4_1_randu" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
result = cv::Matx< double,4,1 >::SWIGTEMPLATEDISAMBIGUATOR randu(arg1,arg2);
resultobj = SWIG_NewPointerObj((new cv::Matx< double,4,1 >(static_cast< const cv::Matx< double,4,1 >& >(result))), SWIGTYPE_p_cv__MatxT_double_4_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_double_4_1_randn(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 ;
SwigValueWrapper< cv::Matx< double,4,1 > > result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_double_4_1_randn",&obj0,&obj1)) SWIG_fail;
ecode1 = SWIG_AsVal_double(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_Matx_double_4_1_randn" "', 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 '" "_Matx_double_4_1_randn" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
result = cv::Matx< double,4,1 >::SWIGTEMPLATEDISAMBIGUATOR randn(arg1,arg2);
resultobj = SWIG_NewPointerObj((new cv::Matx< double,4,1 >(static_cast< const cv::Matx< double,4,1 >& >(result))), SWIGTYPE_p_cv__MatxT_double_4_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_double_4_1_dot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< double,4,1 > *arg1 = (cv::Matx< double,4,1 > *) 0 ;
cv::Matx< double,4,1 > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
double result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_double_4_1_dot",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_double_4_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_double_4_1_dot" "', argument " "1"" of type '" "cv::Matx< double,4,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< double,4,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_double_4_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_double_4_1_dot" "', argument " "2"" of type '" "cv::Matx< double,4,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Matx_double_4_1_dot" "', argument " "2"" of type '" "cv::Matx< double,4,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< double,4,1 > * >(argp2);
result = (double)((cv::Matx< double,4,1 > const *)arg1)->dot((cv::Matx< double,4,1 > const &)*arg2);
resultobj = SWIG_From_double(static_cast< double >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_double_4_1_ddot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< double,4,1 > *arg1 = (cv::Matx< double,4,1 > *) 0 ;
cv::Matx< double,4,1 > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
double result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_double_4_1_ddot",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_double_4_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_double_4_1_ddot" "', argument " "1"" of type '" "cv::Matx< double,4,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< double,4,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_double_4_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_double_4_1_ddot" "', argument " "2"" of type '" "cv::Matx< double,4,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Matx_double_4_1_ddot" "', argument " "2"" of type '" "cv::Matx< double,4,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< double,4,1 > * >(argp2);
result = (double)((cv::Matx< double,4,1 > const *)arg1)->ddot((cv::Matx< double,4,1 > const &)*arg2);
resultobj = SWIG_From_double(static_cast< double >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_double_4_1_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< double,4,1 > *arg1 = (cv::Matx< double,4,1 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
SwigValueWrapper< cv::Matx< double,1,4 > > result;
if (!PyArg_ParseTuple(args,(char *)"O:_Matx_double_4_1_t",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_double_4_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_double_4_1_t" "', argument " "1"" of type '" "cv::Matx< double,4,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< double,4,1 > * >(argp1);
result = ((cv::Matx< double,4,1 > const *)arg1)->t();
resultobj = SWIG_NewPointerObj((new cv::Matx< double,1,4 >(static_cast< const cv::Matx< double,1,4 >& >(result))), SWIGTYPE_p_cv__MatxT_double_1_4_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_double_4_1_mul(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< double,4,1 > *arg1 = (cv::Matx< double,4,1 > *) 0 ;
cv::Matx< double,4,1 > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
SwigValueWrapper< cv::Matx< double,4,1 > > result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_double_4_1_mul",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_double_4_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_double_4_1_mul" "', argument " "1"" of type '" "cv::Matx< double,4,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< double,4,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_double_4_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_double_4_1_mul" "', argument " "2"" of type '" "cv::Matx< double,4,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Matx_double_4_1_mul" "', argument " "2"" of type '" "cv::Matx< double,4,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< double,4,1 > * >(argp2);
result = ((cv::Matx< double,4,1 > const *)arg1)->mul((cv::Matx< double,4,1 > const &)*arg2);
resultobj = SWIG_NewPointerObj((new cv::Matx< double,4,1 >(static_cast< const cv::Matx< double,4,1 >& >(result))), SWIGTYPE_p_cv__MatxT_double_4_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_double_4_1_div(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< double,4,1 > *arg1 = (cv::Matx< double,4,1 > *) 0 ;
cv::Matx< double,4,1 > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
SwigValueWrapper< cv::Matx< double,4,1 > > result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_double_4_1_div",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_double_4_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_double_4_1_div" "', argument " "1"" of type '" "cv::Matx< double,4,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< double,4,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_double_4_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_double_4_1_div" "', argument " "2"" of type '" "cv::Matx< double,4,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Matx_double_4_1_div" "', argument " "2"" of type '" "cv::Matx< double,4,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< double,4,1 > * >(argp2);
result = ((cv::Matx< double,4,1 > const *)arg1)->div((cv::Matx< double,4,1 > const &)*arg2);
resultobj = SWIG_NewPointerObj((new cv::Matx< double,4,1 >(static_cast< const cv::Matx< double,4,1 >& >(result))), SWIGTYPE_p_cv__MatxT_double_4_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_double_4_1___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< double,4,1 > *arg1 = (cv::Matx< double,4,1 > *) 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 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:_Matx_double_4_1___call__",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_double_4_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_double_4_1___call__" "', argument " "1"" of type '" "cv::Matx< double,4,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< double,4,1 > * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_Matx_double_4_1___call__" "', 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 '" "_Matx_double_4_1___call__" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
result = (double *) &((cv::Matx< double,4,1 > const *)arg1)->operator ()(arg2,arg3);
resultobj = SWIG_From_double(static_cast< double >(*result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_double_4_1__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< double,4,1 > *arg1 = 0 ;
cv::Matx< double,4,1 > *arg2 = 0 ;
cv::Matx_AddOp 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 ;
cv::Matx< double,4,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Matx_double_4_1",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_double_4_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_double_4_1" "', argument " "1"" of type '" "cv::Matx< double,4,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_double_4_1" "', argument " "1"" of type '" "cv::Matx< double,4,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< double,4,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_double_4_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Matx_double_4_1" "', argument " "2"" of type '" "cv::Matx< double,4,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_double_4_1" "', argument " "2"" of type '" "cv::Matx< double,4,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< double,4,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_AddOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Matx_double_4_1" "', argument " "3"" of type '" "cv::Matx_AddOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_double_4_1" "', argument " "3"" of type '" "cv::Matx_AddOp""'");
} else {
cv::Matx_AddOp * temp = reinterpret_cast< cv::Matx_AddOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Matx< double,4,1 > *)new cv::Matx< double,4,1 >((cv::Matx< double,4,1 > const &)*arg1,(cv::Matx< double,4,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_double_4_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_double_4_1__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< double,4,1 > *arg1 = 0 ;
cv::Matx< double,4,1 > *arg2 = 0 ;
cv::Matx_SubOp 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 ;
cv::Matx< double,4,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Matx_double_4_1",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_double_4_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_double_4_1" "', argument " "1"" of type '" "cv::Matx< double,4,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_double_4_1" "', argument " "1"" of type '" "cv::Matx< double,4,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< double,4,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_double_4_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Matx_double_4_1" "', argument " "2"" of type '" "cv::Matx< double,4,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_double_4_1" "', argument " "2"" of type '" "cv::Matx< double,4,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< double,4,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_SubOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Matx_double_4_1" "', argument " "3"" of type '" "cv::Matx_SubOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_double_4_1" "', argument " "3"" of type '" "cv::Matx_SubOp""'");
} else {
cv::Matx_SubOp * temp = reinterpret_cast< cv::Matx_SubOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Matx< double,4,1 > *)new cv::Matx< double,4,1 >((cv::Matx< double,4,1 > const &)*arg1,(cv::Matx< double,4,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_double_4_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_double_4_1__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< double,4,1 > *arg1 = 0 ;
cv::Matx< double,4,1 > *arg2 = 0 ;
cv::Matx_MulOp 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 ;
cv::Matx< double,4,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Matx_double_4_1",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_double_4_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_double_4_1" "', argument " "1"" of type '" "cv::Matx< double,4,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_double_4_1" "', argument " "1"" of type '" "cv::Matx< double,4,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< double,4,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_double_4_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Matx_double_4_1" "', argument " "2"" of type '" "cv::Matx< double,4,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_double_4_1" "', argument " "2"" of type '" "cv::Matx< double,4,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< double,4,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_MulOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Matx_double_4_1" "', argument " "3"" of type '" "cv::Matx_MulOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_double_4_1" "', argument " "3"" of type '" "cv::Matx_MulOp""'");
} else {
cv::Matx_MulOp * temp = reinterpret_cast< cv::Matx_MulOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Matx< double,4,1 > *)new cv::Matx< double,4,1 >((cv::Matx< double,4,1 > const &)*arg1,(cv::Matx< double,4,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_double_4_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_double_4_1__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< double,4,1 > *arg1 = 0 ;
cv::Matx< double,4,1 > *arg2 = 0 ;
cv::Matx_DivOp 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 ;
cv::Matx< double,4,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Matx_double_4_1",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_double_4_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_double_4_1" "', argument " "1"" of type '" "cv::Matx< double,4,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_double_4_1" "', argument " "1"" of type '" "cv::Matx< double,4,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< double,4,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_double_4_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Matx_double_4_1" "', argument " "2"" of type '" "cv::Matx< double,4,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_double_4_1" "', argument " "2"" of type '" "cv::Matx< double,4,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< double,4,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_DivOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Matx_double_4_1" "', argument " "3"" of type '" "cv::Matx_DivOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_double_4_1" "', argument " "3"" of type '" "cv::Matx_DivOp""'");
} else {
cv::Matx_DivOp * temp = reinterpret_cast< cv::Matx_DivOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Matx< double,4,1 > *)new cv::Matx< double,4,1 >((cv::Matx< double,4,1 > const &)*arg1,(cv::Matx< double,4,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_double_4_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_double_4_1__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< double,1,4 > *arg1 = 0 ;
cv::Matx_TOp arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
cv::Matx< double,4,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:new__Matx_double_4_1",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_double_1_4_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_double_4_1" "', argument " "1"" of type '" "cv::Matx< double,1,4 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_double_4_1" "', argument " "1"" of type '" "cv::Matx< double,1,4 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< double,1,4 > * >(argp1);
{
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__Matx_TOp, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Matx_double_4_1" "', argument " "2"" of type '" "cv::Matx_TOp""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_double_4_1" "', argument " "2"" of type '" "cv::Matx_TOp""'");
} else {
cv::Matx_TOp * temp = reinterpret_cast< cv::Matx_TOp * >(argp2);
arg2 = *temp;
if (SWIG_IsNewObj(res2)) delete temp;
}
}
result = (cv::Matx< double,4,1 > *)new cv::Matx< double,4,1 >((cv::Matx< double,1,4 > const &)*arg1,arg2);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_double_4_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_double_4_1_val_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< double,4,1 > *arg1 = (cv::Matx< double,4,1 > *) 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:_Matx_double_4_1_val_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_double_4_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_double_4_1_val_set" "', argument " "1"" of type '" "cv::Matx< double,4,1 > *""'");
}
arg1 = reinterpret_cast< cv::Matx< double,4,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_double_4_1_val_set" "', argument " "2"" of type '" "double [4*1]""'");
}
arg2 = reinterpret_cast< double * >(argp2);
{
if (arg2) {
size_t ii = 0;
for (; ii < (size_t)4*1; ++ii) *(double *)&arg1->val[ii] = *((double *)arg2 + ii);
} else {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""val""' of type '""double [4*1]""'");
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_double_4_1_val_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< double,4,1 > *arg1 = (cv::Matx< double,4,1 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
double *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:_Matx_double_4_1_val_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_double_4_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_double_4_1_val_get" "', argument " "1"" of type '" "cv::Matx< double,4,1 > *""'");
}
arg1 = reinterpret_cast< cv::Matx< double,4,1 > * >(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_new__Matx_double_4_1__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< cv::Matx< double,4,1 >::value_type,std::allocator< cv::Matx< double,4,1 >::value_type > > arg1 ;
PyObject * obj0 = 0 ;
cv::Matx< double,4,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__Matx_double_4_1",&obj0)) SWIG_fail;
{
std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
int res = swig::asptr(obj0, &ptr);
if (!SWIG_IsOK(res) || !ptr) {
SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new__Matx_double_4_1" "', argument " "1"" of type '" "std::vector< cv::Matx< double,4,1 >::value_type,std::allocator< cv::Matx< double,4,1 >::value_type > >""'");
}
arg1 = *ptr;
if (SWIG_IsNewObj(res)) delete ptr;
}
result = (cv::Matx< double,4,1 > *)new_cv_Matx_Sl_double_Sc_4_Sc_1_Sg___SWIG_6(arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_double_4_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_double_4_1(PyObject *self, PyObject *args) {
Py_ssize_t argc;
PyObject *argv[4] = {
0
};
Py_ssize_t ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = args ? PyObject_Length(args) : 0;
for (ii = 0; (ii < 3) && (ii < argc); 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_double, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_double_4_1__SWIG_0(self, args);
}
}
if (argc == 1) {
int _v;
int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_double_4_1__SWIG_6(self, args);
}
}
if (argc == 2) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_double_1_4_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__Matx_TOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_double_4_1__SWIG_5(self, args);
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_double_4_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_double_4_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_MulOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_double_4_1__SWIG_3(self, args);
}
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_double_4_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_double_4_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_DivOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_double_4_1__SWIG_4(self, args);
}
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_double_4_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_double_4_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_AddOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_double_4_1__SWIG_1(self, args);
}
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_double_4_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_double_4_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_SubOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_double_4_1__SWIG_2(self, args);
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new__Matx_double_4_1'.\n"
" Possible C/C++ prototypes are:\n"
" cv::Matx< double,4,1 >::Matx(double const *)\n"
" cv::Matx< double,4,1 >::Matx(cv::Matx< double,4,1 > const &,cv::Matx< double,4,1 > const &,cv::Matx_AddOp)\n"
" cv::Matx< double,4,1 >::Matx(cv::Matx< double,4,1 > const &,cv::Matx< double,4,1 > const &,cv::Matx_SubOp)\n"
" cv::Matx< double,4,1 >::Matx(cv::Matx< double,4,1 > const &,cv::Matx< double,4,1 > const &,cv::Matx_MulOp)\n"
" cv::Matx< double,4,1 >::Matx(cv::Matx< double,4,1 > const &,cv::Matx< double,4,1 > const &,cv::Matx_DivOp)\n"
" cv::Matx< double,4,1 >::Matx(cv::Matx< double,1,4 > const &,cv::Matx_TOp)\n"
" cv::Matx< double,4,1 >::Matx(std::vector< cv::Matx< double,4,1 >::value_type,std::allocator< cv::Matx< double,4,1 >::value_type > >)\n");
return 0;
}
SWIGINTERN PyObject *_wrap__Matx_double_4_1___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< double,4,1 > *arg1 = (cv::Matx< double,4,1 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
std::string result;
if (!PyArg_ParseTuple(args,(char *)"O:_Matx_double_4_1___str__",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_double_4_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_double_4_1___str__" "', argument " "1"" of type '" "cv::Matx< double,4,1 > *""'");
}
arg1 = reinterpret_cast< cv::Matx< double,4,1 > * >(argp1);
result = cv_Matx_Sl_double_Sc_4_Sc_1_Sg____str__(arg1);
resultobj = SWIG_From_std_string(static_cast< std::string >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete__Matx_double_4_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< double,4,1 > *arg1 = (cv::Matx< double,4,1 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete__Matx_double_4_1",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_double_4_1_t, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__Matx_double_4_1" "', argument " "1"" of type '" "cv::Matx< double,4,1 > *""'");
}
arg1 = reinterpret_cast< cv::Matx< double,4,1 > * >(argp1);
delete arg1;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_Matx_double_4_1_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_cv__MatxT_double_4_1_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_new__Vec_double_4__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
double *arg1 = (double *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
cv::Vec< double,4 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__Vec_double_4",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Vec_double_4" "', argument " "1"" of type '" "double const *""'");
}
arg1 = reinterpret_cast< double * >(argp1);
result = (cv::Vec< double,4 > *)new cv::Vec< double,4 >((double const *)arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__VecT_double_4_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Vec_double_4__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Vec< double,4 > *arg1 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
cv::Vec< double,4 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__Vec_double_4",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__VecT_double_4_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Vec_double_4" "', argument " "1"" of type '" "cv::Vec< double,4 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_double_4" "', argument " "1"" of type '" "cv::Vec< double,4 > const &""'");
}
arg1 = reinterpret_cast< cv::Vec< double,4 > * >(argp1);
result = (cv::Vec< double,4 > *)new cv::Vec< double,4 >((cv::Vec< double,4 > const &)*arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__VecT_double_4_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Vec_double_4_all(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
double arg1 ;
double val1 ;
int ecode1 = 0 ;
PyObject * obj0 = 0 ;
SwigValueWrapper< cv::Vec< double,4 > > result;
if (!PyArg_ParseTuple(args,(char *)"O:_Vec_double_4_all",&obj0)) SWIG_fail;
ecode1 = SWIG_AsVal_double(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_Vec_double_4_all" "', argument " "1"" of type '" "double""'");
}
arg1 = static_cast< double >(val1);
result = cv::Vec< double,4 >::SWIGTEMPLATEDISAMBIGUATOR all(arg1);
resultobj = SWIG_NewPointerObj((new cv::Vec< double,4 >(static_cast< const cv::Vec< double,4 >& >(result))), SWIGTYPE_p_cv__VecT_double_4_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Vec_double_4_mul(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Vec< double,4 > *arg1 = (cv::Vec< double,4 > *) 0 ;
cv::Vec< double,4 > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
SwigValueWrapper< cv::Vec< double,4 > > result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Vec_double_4_mul",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__VecT_double_4_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Vec_double_4_mul" "', argument " "1"" of type '" "cv::Vec< double,4 > const *""'");
}
arg1 = reinterpret_cast< cv::Vec< double,4 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__VecT_double_4_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Vec_double_4_mul" "', argument " "2"" of type '" "cv::Vec< double,4 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Vec_double_4_mul" "', argument " "2"" of type '" "cv::Vec< double,4 > const &""'");
}
arg2 = reinterpret_cast< cv::Vec< double,4 > * >(argp2);
result = ((cv::Vec< double,4 > const *)arg1)->mul((cv::Vec< double,4 > const &)*arg2);
resultobj = SWIG_NewPointerObj((new cv::Vec< double,4 >(static_cast< const cv::Vec< double,4 >& >(result))), SWIGTYPE_p_cv__VecT_double_4_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Vec_double_4___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Vec< double,4 > *arg1 = (cv::Vec< double,4 > *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
double *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:_Vec_double_4___call__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__VecT_double_4_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Vec_double_4___call__" "', argument " "1"" of type '" "cv::Vec< double,4 > const *""'");
}
arg1 = reinterpret_cast< cv::Vec< double,4 > * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_Vec_double_4___call__" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
result = (double *) &((cv::Vec< double,4 > const *)arg1)->operator ()(arg2);
resultobj = SWIG_From_double(static_cast< double >(*result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Vec_double_4__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< double,4,1 > *arg1 = 0 ;
cv::Matx< double,4,1 > *arg2 = 0 ;
cv::Matx_AddOp 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 ;
cv::Vec< double,4 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Vec_double_4",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_double_4_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Vec_double_4" "', argument " "1"" of type '" "cv::Matx< double,4,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_double_4" "', argument " "1"" of type '" "cv::Matx< double,4,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< double,4,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_double_4_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Vec_double_4" "', argument " "2"" of type '" "cv::Matx< double,4,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_double_4" "', argument " "2"" of type '" "cv::Matx< double,4,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< double,4,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_AddOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Vec_double_4" "', argument " "3"" of type '" "cv::Matx_AddOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_double_4" "', argument " "3"" of type '" "cv::Matx_AddOp""'");
} else {
cv::Matx_AddOp * temp = reinterpret_cast< cv::Matx_AddOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Vec< double,4 > *)new cv::Vec< double,4 >((cv::Matx< double,4,1 > const &)*arg1,(cv::Matx< double,4,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__VecT_double_4_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Vec_double_4__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< double,4,1 > *arg1 = 0 ;
cv::Matx< double,4,1 > *arg2 = 0 ;
cv::Matx_SubOp 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 ;
cv::Vec< double,4 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Vec_double_4",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_double_4_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Vec_double_4" "', argument " "1"" of type '" "cv::Matx< double,4,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_double_4" "', argument " "1"" of type '" "cv::Matx< double,4,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< double,4,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_double_4_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Vec_double_4" "', argument " "2"" of type '" "cv::Matx< double,4,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_double_4" "', argument " "2"" of type '" "cv::Matx< double,4,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< double,4,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_SubOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Vec_double_4" "', argument " "3"" of type '" "cv::Matx_SubOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_double_4" "', argument " "3"" of type '" "cv::Matx_SubOp""'");
} else {
cv::Matx_SubOp * temp = reinterpret_cast< cv::Matx_SubOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Vec< double,4 > *)new cv::Vec< double,4 >((cv::Matx< double,4,1 > const &)*arg1,(cv::Matx< double,4,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__VecT_double_4_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Vec_double_4__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< cv::Vec< double,4 >::value_type,std::allocator< cv::Vec< double,4 >::value_type > > arg1 ;
PyObject * obj0 = 0 ;
cv::Vec< double,4 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__Vec_double_4",&obj0)) SWIG_fail;
{
std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
int res = swig::asptr(obj0, &ptr);
if (!SWIG_IsOK(res) || !ptr) {
SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new__Vec_double_4" "', argument " "1"" of type '" "std::vector< cv::Vec< double,4 >::value_type,std::allocator< cv::Vec< double,4 >::value_type > >""'");
}
arg1 = *ptr;
if (SWIG_IsNewObj(res)) delete ptr;
}
result = (cv::Vec< double,4 > *)new_cv_Vec_Sl_double_Sc_4_Sg___SWIG_4(arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__VecT_double_4_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Vec_double_4(PyObject *self, PyObject *args) {
Py_ssize_t argc;
PyObject *argv[4] = {
0
};
Py_ssize_t ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = args ? PyObject_Length(args) : 0;
for (ii = 0; (ii < 3) && (ii < argc); 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_double, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Vec_double_4__SWIG_0(self, args);
}
}
if (argc == 1) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__VecT_double_4_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Vec_double_4__SWIG_1(self, args);
}
}
if (argc == 1) {
int _v;
int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Vec_double_4__SWIG_4(self, args);
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_double_4_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_double_4_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_SubOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Vec_double_4__SWIG_3(self, args);
}
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_double_4_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_double_4_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_AddOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Vec_double_4__SWIG_2(self, args);
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new__Vec_double_4'.\n"
" Possible C/C++ prototypes are:\n"
" cv::Vec< double,4 >::Vec(double const *)\n"
" cv::Vec< double,4 >::Vec(cv::Vec< double,4 > const &)\n"
" cv::Vec< double,4 >::Vec(cv::Matx< double,4,1 > const &,cv::Matx< double,4,1 > const &,cv::Matx_AddOp)\n"
" cv::Vec< double,4 >::Vec(cv::Matx< double,4,1 > const &,cv::Matx< double,4,1 > const &,cv::Matx_SubOp)\n"
" cv::Vec< double,4 >::Vec(std::vector< cv::Vec< double,4 >::value_type,std::allocator< cv::Vec< double,4 >::value_type > >)\n");
return 0;
}
SWIGINTERN PyObject *_wrap__Vec_double_4___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Vec< double,4 > *arg1 = (cv::Vec< double,4 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
std::string result;
if (!PyArg_ParseTuple(args,(char *)"O:_Vec_double_4___str__",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__VecT_double_4_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Vec_double_4___str__" "', argument " "1"" of type '" "cv::Vec< double,4 > *""'");
}
arg1 = reinterpret_cast< cv::Vec< double,4 > * >(argp1);
result = cv_Vec_Sl_double_Sc_4_Sg____str__(arg1);
resultobj = SWIG_From_std_string(static_cast< std::string >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete__Vec_double_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Vec< double,4 > *arg1 = (cv::Vec< double,4 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete__Vec_double_4",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__VecT_double_4_t, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__Vec_double_4" "', argument " "1"" of type '" "cv::Vec< double,4 > *""'");
}
arg1 = reinterpret_cast< cv::Vec< double,4 > * >(argp1);
delete arg1;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_Vec_double_4_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_cv__VecT_double_4_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_new__DataType_Vec_double_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::DataType< cv::Vec< double,4 > > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new__DataType_Vec_double_4")) SWIG_fail;
result = (cv::DataType< cv::Vec< double,4 > > *)new cv::DataType< cv::Vec< double,4 > >();
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__DataTypeT_cv__VecT_double_4_t_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete__DataType_Vec_double_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::DataType< cv::Vec< double,4 > > *arg1 = (cv::DataType< cv::Vec< double,4 > > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete__DataType_Vec_double_4",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__DataTypeT_cv__VecT_double_4_t_t, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__DataType_Vec_double_4" "', argument " "1"" of type '" "cv::DataType< cv::Vec< double,4 > > *""'");
}
arg1 = reinterpret_cast< cv::DataType< cv::Vec< double,4 > > * >(argp1);
delete arg1;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_DataType_Vec_double_4_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_cv__DataTypeT_cv__VecT_double_4_t_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_new__Matx_double_6_1__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
double *arg1 = (double *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
cv::Matx< double,6,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__Matx_double_6_1",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_double_6_1" "', argument " "1"" of type '" "double const *""'");
}
arg1 = reinterpret_cast< double * >(argp1);
result = (cv::Matx< double,6,1 > *)new cv::Matx< double,6,1 >((double const *)arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_double_6_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_double_6_1_all(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
double arg1 ;
double val1 ;
int ecode1 = 0 ;
PyObject * obj0 = 0 ;
SwigValueWrapper< cv::Matx< double,6,1 > > result;
if (!PyArg_ParseTuple(args,(char *)"O:_Matx_double_6_1_all",&obj0)) SWIG_fail;
ecode1 = SWIG_AsVal_double(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_Matx_double_6_1_all" "', argument " "1"" of type '" "double""'");
}
arg1 = static_cast< double >(val1);
result = cv::Matx< double,6,1 >::SWIGTEMPLATEDISAMBIGUATOR all(arg1);
resultobj = SWIG_NewPointerObj((new cv::Matx< double,6,1 >(static_cast< const cv::Matx< double,6,1 >& >(result))), SWIGTYPE_p_cv__MatxT_double_6_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_double_6_1_zeros(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
SwigValueWrapper< cv::Matx< double,6,1 > > result;
if (!PyArg_ParseTuple(args,(char *)":_Matx_double_6_1_zeros")) SWIG_fail;
result = cv::Matx< double,6,1 >::SWIGTEMPLATEDISAMBIGUATOR zeros();
resultobj = SWIG_NewPointerObj((new cv::Matx< double,6,1 >(static_cast< const cv::Matx< double,6,1 >& >(result))), SWIGTYPE_p_cv__MatxT_double_6_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_double_6_1_ones(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
SwigValueWrapper< cv::Matx< double,6,1 > > result;
if (!PyArg_ParseTuple(args,(char *)":_Matx_double_6_1_ones")) SWIG_fail;
result = cv::Matx< double,6,1 >::SWIGTEMPLATEDISAMBIGUATOR ones();
resultobj = SWIG_NewPointerObj((new cv::Matx< double,6,1 >(static_cast< const cv::Matx< double,6,1 >& >(result))), SWIGTYPE_p_cv__MatxT_double_6_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_double_6_1_eye(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
SwigValueWrapper< cv::Matx< double,6,1 > > result;
if (!PyArg_ParseTuple(args,(char *)":_Matx_double_6_1_eye")) SWIG_fail;
result = cv::Matx< double,6,1 >::SWIGTEMPLATEDISAMBIGUATOR eye();
resultobj = SWIG_NewPointerObj((new cv::Matx< double,6,1 >(static_cast< const cv::Matx< double,6,1 >& >(result))), SWIGTYPE_p_cv__MatxT_double_6_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_double_6_1_randu(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 ;
SwigValueWrapper< cv::Matx< double,6,1 > > result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_double_6_1_randu",&obj0,&obj1)) SWIG_fail;
ecode1 = SWIG_AsVal_double(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_Matx_double_6_1_randu" "', 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 '" "_Matx_double_6_1_randu" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
result = cv::Matx< double,6,1 >::SWIGTEMPLATEDISAMBIGUATOR randu(arg1,arg2);
resultobj = SWIG_NewPointerObj((new cv::Matx< double,6,1 >(static_cast< const cv::Matx< double,6,1 >& >(result))), SWIGTYPE_p_cv__MatxT_double_6_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_double_6_1_randn(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 ;
SwigValueWrapper< cv::Matx< double,6,1 > > result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_double_6_1_randn",&obj0,&obj1)) SWIG_fail;
ecode1 = SWIG_AsVal_double(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_Matx_double_6_1_randn" "', 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 '" "_Matx_double_6_1_randn" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
result = cv::Matx< double,6,1 >::SWIGTEMPLATEDISAMBIGUATOR randn(arg1,arg2);
resultobj = SWIG_NewPointerObj((new cv::Matx< double,6,1 >(static_cast< const cv::Matx< double,6,1 >& >(result))), SWIGTYPE_p_cv__MatxT_double_6_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_double_6_1_dot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< double,6,1 > *arg1 = (cv::Matx< double,6,1 > *) 0 ;
cv::Matx< double,6,1 > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
double result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_double_6_1_dot",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_double_6_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_double_6_1_dot" "', argument " "1"" of type '" "cv::Matx< double,6,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< double,6,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_double_6_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_double_6_1_dot" "', argument " "2"" of type '" "cv::Matx< double,6,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Matx_double_6_1_dot" "', argument " "2"" of type '" "cv::Matx< double,6,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< double,6,1 > * >(argp2);
result = (double)((cv::Matx< double,6,1 > const *)arg1)->dot((cv::Matx< double,6,1 > const &)*arg2);
resultobj = SWIG_From_double(static_cast< double >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_double_6_1_ddot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< double,6,1 > *arg1 = (cv::Matx< double,6,1 > *) 0 ;
cv::Matx< double,6,1 > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
double result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_double_6_1_ddot",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_double_6_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_double_6_1_ddot" "', argument " "1"" of type '" "cv::Matx< double,6,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< double,6,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_double_6_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_double_6_1_ddot" "', argument " "2"" of type '" "cv::Matx< double,6,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Matx_double_6_1_ddot" "', argument " "2"" of type '" "cv::Matx< double,6,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< double,6,1 > * >(argp2);
result = (double)((cv::Matx< double,6,1 > const *)arg1)->ddot((cv::Matx< double,6,1 > const &)*arg2);
resultobj = SWIG_From_double(static_cast< double >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_double_6_1_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< double,6,1 > *arg1 = (cv::Matx< double,6,1 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
SwigValueWrapper< cv::Matx< double,1,6 > > result;
if (!PyArg_ParseTuple(args,(char *)"O:_Matx_double_6_1_t",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_double_6_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_double_6_1_t" "', argument " "1"" of type '" "cv::Matx< double,6,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< double,6,1 > * >(argp1);
result = ((cv::Matx< double,6,1 > const *)arg1)->t();
resultobj = SWIG_NewPointerObj((new cv::Matx< double,1,6 >(static_cast< const cv::Matx< double,1,6 >& >(result))), SWIGTYPE_p_cv__MatxT_double_1_6_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_double_6_1_mul(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< double,6,1 > *arg1 = (cv::Matx< double,6,1 > *) 0 ;
cv::Matx< double,6,1 > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
SwigValueWrapper< cv::Matx< double,6,1 > > result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_double_6_1_mul",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_double_6_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_double_6_1_mul" "', argument " "1"" of type '" "cv::Matx< double,6,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< double,6,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_double_6_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_double_6_1_mul" "', argument " "2"" of type '" "cv::Matx< double,6,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Matx_double_6_1_mul" "', argument " "2"" of type '" "cv::Matx< double,6,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< double,6,1 > * >(argp2);
result = ((cv::Matx< double,6,1 > const *)arg1)->mul((cv::Matx< double,6,1 > const &)*arg2);
resultobj = SWIG_NewPointerObj((new cv::Matx< double,6,1 >(static_cast< const cv::Matx< double,6,1 >& >(result))), SWIGTYPE_p_cv__MatxT_double_6_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_double_6_1_div(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< double,6,1 > *arg1 = (cv::Matx< double,6,1 > *) 0 ;
cv::Matx< double,6,1 > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
SwigValueWrapper< cv::Matx< double,6,1 > > result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Matx_double_6_1_div",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_double_6_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_double_6_1_div" "', argument " "1"" of type '" "cv::Matx< double,6,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< double,6,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_double_6_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_double_6_1_div" "', argument " "2"" of type '" "cv::Matx< double,6,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Matx_double_6_1_div" "', argument " "2"" of type '" "cv::Matx< double,6,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< double,6,1 > * >(argp2);
result = ((cv::Matx< double,6,1 > const *)arg1)->div((cv::Matx< double,6,1 > const &)*arg2);
resultobj = SWIG_NewPointerObj((new cv::Matx< double,6,1 >(static_cast< const cv::Matx< double,6,1 >& >(result))), SWIGTYPE_p_cv__MatxT_double_6_1_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_double_6_1___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< double,6,1 > *arg1 = (cv::Matx< double,6,1 > *) 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 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:_Matx_double_6_1___call__",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_double_6_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_double_6_1___call__" "', argument " "1"" of type '" "cv::Matx< double,6,1 > const *""'");
}
arg1 = reinterpret_cast< cv::Matx< double,6,1 > * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_Matx_double_6_1___call__" "', 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 '" "_Matx_double_6_1___call__" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
result = (double *) &((cv::Matx< double,6,1 > const *)arg1)->operator ()(arg2,arg3);
resultobj = SWIG_From_double(static_cast< double >(*result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_double_6_1__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< double,6,1 > *arg1 = 0 ;
cv::Matx< double,6,1 > *arg2 = 0 ;
cv::Matx_AddOp 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 ;
cv::Matx< double,6,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Matx_double_6_1",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_double_6_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_double_6_1" "', argument " "1"" of type '" "cv::Matx< double,6,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_double_6_1" "', argument " "1"" of type '" "cv::Matx< double,6,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< double,6,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_double_6_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Matx_double_6_1" "', argument " "2"" of type '" "cv::Matx< double,6,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_double_6_1" "', argument " "2"" of type '" "cv::Matx< double,6,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< double,6,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_AddOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Matx_double_6_1" "', argument " "3"" of type '" "cv::Matx_AddOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_double_6_1" "', argument " "3"" of type '" "cv::Matx_AddOp""'");
} else {
cv::Matx_AddOp * temp = reinterpret_cast< cv::Matx_AddOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Matx< double,6,1 > *)new cv::Matx< double,6,1 >((cv::Matx< double,6,1 > const &)*arg1,(cv::Matx< double,6,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_double_6_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_double_6_1__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< double,6,1 > *arg1 = 0 ;
cv::Matx< double,6,1 > *arg2 = 0 ;
cv::Matx_SubOp 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 ;
cv::Matx< double,6,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Matx_double_6_1",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_double_6_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_double_6_1" "', argument " "1"" of type '" "cv::Matx< double,6,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_double_6_1" "', argument " "1"" of type '" "cv::Matx< double,6,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< double,6,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_double_6_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Matx_double_6_1" "', argument " "2"" of type '" "cv::Matx< double,6,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_double_6_1" "', argument " "2"" of type '" "cv::Matx< double,6,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< double,6,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_SubOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Matx_double_6_1" "', argument " "3"" of type '" "cv::Matx_SubOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_double_6_1" "', argument " "3"" of type '" "cv::Matx_SubOp""'");
} else {
cv::Matx_SubOp * temp = reinterpret_cast< cv::Matx_SubOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Matx< double,6,1 > *)new cv::Matx< double,6,1 >((cv::Matx< double,6,1 > const &)*arg1,(cv::Matx< double,6,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_double_6_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_double_6_1__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< double,6,1 > *arg1 = 0 ;
cv::Matx< double,6,1 > *arg2 = 0 ;
cv::Matx_MulOp 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 ;
cv::Matx< double,6,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Matx_double_6_1",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_double_6_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_double_6_1" "', argument " "1"" of type '" "cv::Matx< double,6,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_double_6_1" "', argument " "1"" of type '" "cv::Matx< double,6,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< double,6,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_double_6_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Matx_double_6_1" "', argument " "2"" of type '" "cv::Matx< double,6,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_double_6_1" "', argument " "2"" of type '" "cv::Matx< double,6,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< double,6,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_MulOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Matx_double_6_1" "', argument " "3"" of type '" "cv::Matx_MulOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_double_6_1" "', argument " "3"" of type '" "cv::Matx_MulOp""'");
} else {
cv::Matx_MulOp * temp = reinterpret_cast< cv::Matx_MulOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Matx< double,6,1 > *)new cv::Matx< double,6,1 >((cv::Matx< double,6,1 > const &)*arg1,(cv::Matx< double,6,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_double_6_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_double_6_1__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< double,6,1 > *arg1 = 0 ;
cv::Matx< double,6,1 > *arg2 = 0 ;
cv::Matx_DivOp 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 ;
cv::Matx< double,6,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Matx_double_6_1",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_double_6_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_double_6_1" "', argument " "1"" of type '" "cv::Matx< double,6,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_double_6_1" "', argument " "1"" of type '" "cv::Matx< double,6,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< double,6,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_double_6_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Matx_double_6_1" "', argument " "2"" of type '" "cv::Matx< double,6,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_double_6_1" "', argument " "2"" of type '" "cv::Matx< double,6,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< double,6,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_DivOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Matx_double_6_1" "', argument " "3"" of type '" "cv::Matx_DivOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_double_6_1" "', argument " "3"" of type '" "cv::Matx_DivOp""'");
} else {
cv::Matx_DivOp * temp = reinterpret_cast< cv::Matx_DivOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Matx< double,6,1 > *)new cv::Matx< double,6,1 >((cv::Matx< double,6,1 > const &)*arg1,(cv::Matx< double,6,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_double_6_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_double_6_1__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< double,1,6 > *arg1 = 0 ;
cv::Matx_TOp arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
cv::Matx< double,6,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:new__Matx_double_6_1",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_double_1_6_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Matx_double_6_1" "', argument " "1"" of type '" "cv::Matx< double,1,6 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_double_6_1" "', argument " "1"" of type '" "cv::Matx< double,1,6 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< double,1,6 > * >(argp1);
{
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__Matx_TOp, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Matx_double_6_1" "', argument " "2"" of type '" "cv::Matx_TOp""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Matx_double_6_1" "', argument " "2"" of type '" "cv::Matx_TOp""'");
} else {
cv::Matx_TOp * temp = reinterpret_cast< cv::Matx_TOp * >(argp2);
arg2 = *temp;
if (SWIG_IsNewObj(res2)) delete temp;
}
}
result = (cv::Matx< double,6,1 > *)new cv::Matx< double,6,1 >((cv::Matx< double,1,6 > const &)*arg1,arg2);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_double_6_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_double_6_1_val_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< double,6,1 > *arg1 = (cv::Matx< double,6,1 > *) 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:_Matx_double_6_1_val_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_double_6_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_double_6_1_val_set" "', argument " "1"" of type '" "cv::Matx< double,6,1 > *""'");
}
arg1 = reinterpret_cast< cv::Matx< double,6,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Matx_double_6_1_val_set" "', argument " "2"" of type '" "double [6*1]""'");
}
arg2 = reinterpret_cast< double * >(argp2);
{
if (arg2) {
size_t ii = 0;
for (; ii < (size_t)6*1; ++ii) *(double *)&arg1->val[ii] = *((double *)arg2 + ii);
} else {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""val""' of type '""double [6*1]""'");
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Matx_double_6_1_val_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< double,6,1 > *arg1 = (cv::Matx< double,6,1 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
double *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:_Matx_double_6_1_val_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_double_6_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_double_6_1_val_get" "', argument " "1"" of type '" "cv::Matx< double,6,1 > *""'");
}
arg1 = reinterpret_cast< cv::Matx< double,6,1 > * >(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_new__Matx_double_6_1__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< cv::Matx< double,6,1 >::value_type,std::allocator< cv::Matx< double,6,1 >::value_type > > arg1 ;
PyObject * obj0 = 0 ;
cv::Matx< double,6,1 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__Matx_double_6_1",&obj0)) SWIG_fail;
{
std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
int res = swig::asptr(obj0, &ptr);
if (!SWIG_IsOK(res) || !ptr) {
SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new__Matx_double_6_1" "', argument " "1"" of type '" "std::vector< cv::Matx< double,6,1 >::value_type,std::allocator< cv::Matx< double,6,1 >::value_type > >""'");
}
arg1 = *ptr;
if (SWIG_IsNewObj(res)) delete ptr;
}
result = (cv::Matx< double,6,1 > *)new_cv_Matx_Sl_double_Sc_6_Sc_1_Sg___SWIG_6(arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__MatxT_double_6_1_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Matx_double_6_1(PyObject *self, PyObject *args) {
Py_ssize_t argc;
PyObject *argv[4] = {
0
};
Py_ssize_t ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = args ? PyObject_Length(args) : 0;
for (ii = 0; (ii < 3) && (ii < argc); 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_double, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_double_6_1__SWIG_0(self, args);
}
}
if (argc == 1) {
int _v;
int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_double_6_1__SWIG_6(self, args);
}
}
if (argc == 2) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_double_1_6_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__Matx_TOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_double_6_1__SWIG_5(self, args);
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_double_6_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_double_6_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_MulOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_double_6_1__SWIG_3(self, args);
}
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_double_6_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_double_6_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_DivOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_double_6_1__SWIG_4(self, args);
}
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_double_6_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_double_6_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_AddOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_double_6_1__SWIG_1(self, args);
}
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_double_6_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_double_6_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_SubOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Matx_double_6_1__SWIG_2(self, args);
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new__Matx_double_6_1'.\n"
" Possible C/C++ prototypes are:\n"
" cv::Matx< double,6,1 >::Matx(double const *)\n"
" cv::Matx< double,6,1 >::Matx(cv::Matx< double,6,1 > const &,cv::Matx< double,6,1 > const &,cv::Matx_AddOp)\n"
" cv::Matx< double,6,1 >::Matx(cv::Matx< double,6,1 > const &,cv::Matx< double,6,1 > const &,cv::Matx_SubOp)\n"
" cv::Matx< double,6,1 >::Matx(cv::Matx< double,6,1 > const &,cv::Matx< double,6,1 > const &,cv::Matx_MulOp)\n"
" cv::Matx< double,6,1 >::Matx(cv::Matx< double,6,1 > const &,cv::Matx< double,6,1 > const &,cv::Matx_DivOp)\n"
" cv::Matx< double,6,1 >::Matx(cv::Matx< double,1,6 > const &,cv::Matx_TOp)\n"
" cv::Matx< double,6,1 >::Matx(std::vector< cv::Matx< double,6,1 >::value_type,std::allocator< cv::Matx< double,6,1 >::value_type > >)\n");
return 0;
}
SWIGINTERN PyObject *_wrap__Matx_double_6_1___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< double,6,1 > *arg1 = (cv::Matx< double,6,1 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
std::string result;
if (!PyArg_ParseTuple(args,(char *)"O:_Matx_double_6_1___str__",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_double_6_1_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Matx_double_6_1___str__" "', argument " "1"" of type '" "cv::Matx< double,6,1 > *""'");
}
arg1 = reinterpret_cast< cv::Matx< double,6,1 > * >(argp1);
result = cv_Matx_Sl_double_Sc_6_Sc_1_Sg____str__(arg1);
resultobj = SWIG_From_std_string(static_cast< std::string >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete__Matx_double_6_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< double,6,1 > *arg1 = (cv::Matx< double,6,1 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete__Matx_double_6_1",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__MatxT_double_6_1_t, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__Matx_double_6_1" "', argument " "1"" of type '" "cv::Matx< double,6,1 > *""'");
}
arg1 = reinterpret_cast< cv::Matx< double,6,1 > * >(argp1);
delete arg1;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_Matx_double_6_1_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_cv__MatxT_double_6_1_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_new__Vec_double_6__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
double *arg1 = (double *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
cv::Vec< double,6 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__Vec_double_6",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Vec_double_6" "', argument " "1"" of type '" "double const *""'");
}
arg1 = reinterpret_cast< double * >(argp1);
result = (cv::Vec< double,6 > *)new cv::Vec< double,6 >((double const *)arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__VecT_double_6_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Vec_double_6__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Vec< double,6 > *arg1 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
cv::Vec< double,6 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__Vec_double_6",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__VecT_double_6_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Vec_double_6" "', argument " "1"" of type '" "cv::Vec< double,6 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_double_6" "', argument " "1"" of type '" "cv::Vec< double,6 > const &""'");
}
arg1 = reinterpret_cast< cv::Vec< double,6 > * >(argp1);
result = (cv::Vec< double,6 > *)new cv::Vec< double,6 >((cv::Vec< double,6 > const &)*arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__VecT_double_6_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Vec_double_6_all(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
double arg1 ;
double val1 ;
int ecode1 = 0 ;
PyObject * obj0 = 0 ;
SwigValueWrapper< cv::Vec< double,6 > > result;
if (!PyArg_ParseTuple(args,(char *)"O:_Vec_double_6_all",&obj0)) SWIG_fail;
ecode1 = SWIG_AsVal_double(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_Vec_double_6_all" "', argument " "1"" of type '" "double""'");
}
arg1 = static_cast< double >(val1);
result = cv::Vec< double,6 >::SWIGTEMPLATEDISAMBIGUATOR all(arg1);
resultobj = SWIG_NewPointerObj((new cv::Vec< double,6 >(static_cast< const cv::Vec< double,6 >& >(result))), SWIGTYPE_p_cv__VecT_double_6_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Vec_double_6_mul(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Vec< double,6 > *arg1 = (cv::Vec< double,6 > *) 0 ;
cv::Vec< double,6 > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
SwigValueWrapper< cv::Vec< double,6 > > result;
if (!PyArg_ParseTuple(args,(char *)"OO:_Vec_double_6_mul",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__VecT_double_6_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Vec_double_6_mul" "', argument " "1"" of type '" "cv::Vec< double,6 > const *""'");
}
arg1 = reinterpret_cast< cv::Vec< double,6 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__VecT_double_6_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_Vec_double_6_mul" "', argument " "2"" of type '" "cv::Vec< double,6 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_Vec_double_6_mul" "', argument " "2"" of type '" "cv::Vec< double,6 > const &""'");
}
arg2 = reinterpret_cast< cv::Vec< double,6 > * >(argp2);
result = ((cv::Vec< double,6 > const *)arg1)->mul((cv::Vec< double,6 > const &)*arg2);
resultobj = SWIG_NewPointerObj((new cv::Vec< double,6 >(static_cast< const cv::Vec< double,6 >& >(result))), SWIGTYPE_p_cv__VecT_double_6_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__Vec_double_6___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Vec< double,6 > *arg1 = (cv::Vec< double,6 > *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
double *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:_Vec_double_6___call__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__VecT_double_6_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Vec_double_6___call__" "', argument " "1"" of type '" "cv::Vec< double,6 > const *""'");
}
arg1 = reinterpret_cast< cv::Vec< double,6 > * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_Vec_double_6___call__" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
result = (double *) &((cv::Vec< double,6 > const *)arg1)->operator ()(arg2);
resultobj = SWIG_From_double(static_cast< double >(*result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Vec_double_6__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< double,6,1 > *arg1 = 0 ;
cv::Matx< double,6,1 > *arg2 = 0 ;
cv::Matx_AddOp 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 ;
cv::Vec< double,6 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Vec_double_6",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_double_6_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Vec_double_6" "', argument " "1"" of type '" "cv::Matx< double,6,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_double_6" "', argument " "1"" of type '" "cv::Matx< double,6,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< double,6,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_double_6_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Vec_double_6" "', argument " "2"" of type '" "cv::Matx< double,6,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_double_6" "', argument " "2"" of type '" "cv::Matx< double,6,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< double,6,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_AddOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Vec_double_6" "', argument " "3"" of type '" "cv::Matx_AddOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_double_6" "', argument " "3"" of type '" "cv::Matx_AddOp""'");
} else {
cv::Matx_AddOp * temp = reinterpret_cast< cv::Matx_AddOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Vec< double,6 > *)new cv::Vec< double,6 >((cv::Matx< double,6,1 > const &)*arg1,(cv::Matx< double,6,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__VecT_double_6_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Vec_double_6__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Matx< double,6,1 > *arg1 = 0 ;
cv::Matx< double,6,1 > *arg2 = 0 ;
cv::Matx_SubOp 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 ;
cv::Vec< double,6 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new__Vec_double_6",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cv__MatxT_double_6_1_t, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__Vec_double_6" "', argument " "1"" of type '" "cv::Matx< double,6,1 > const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_double_6" "', argument " "1"" of type '" "cv::Matx< double,6,1 > const &""'");
}
arg1 = reinterpret_cast< cv::Matx< double,6,1 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__MatxT_double_6_1_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__Vec_double_6" "', argument " "2"" of type '" "cv::Matx< double,6,1 > const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_double_6" "', argument " "2"" of type '" "cv::Matx< double,6,1 > const &""'");
}
arg2 = reinterpret_cast< cv::Matx< double,6,1 > * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Matx_SubOp, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new__Vec_double_6" "', argument " "3"" of type '" "cv::Matx_SubOp""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__Vec_double_6" "', argument " "3"" of type '" "cv::Matx_SubOp""'");
} else {
cv::Matx_SubOp * temp = reinterpret_cast< cv::Matx_SubOp * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (cv::Vec< double,6 > *)new cv::Vec< double,6 >((cv::Matx< double,6,1 > const &)*arg1,(cv::Matx< double,6,1 > const &)*arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__VecT_double_6_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Vec_double_6__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< cv::Vec< double,6 >::value_type,std::allocator< cv::Vec< double,6 >::value_type > > arg1 ;
PyObject * obj0 = 0 ;
cv::Vec< double,6 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new__Vec_double_6",&obj0)) SWIG_fail;
{
std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
int res = swig::asptr(obj0, &ptr);
if (!SWIG_IsOK(res) || !ptr) {
SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new__Vec_double_6" "', argument " "1"" of type '" "std::vector< cv::Vec< double,6 >::value_type,std::allocator< cv::Vec< double,6 >::value_type > >""'");
}
arg1 = *ptr;
if (SWIG_IsNewObj(res)) delete ptr;
}
result = (cv::Vec< double,6 > *)new_cv_Vec_Sl_double_Sc_6_Sg___SWIG_4(arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__VecT_double_6_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new__Vec_double_6(PyObject *self, PyObject *args) {
Py_ssize_t argc;
PyObject *argv[4] = {
0
};
Py_ssize_t ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = args ? PyObject_Length(args) : 0;
for (ii = 0; (ii < 3) && (ii < argc); 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_double, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Vec_double_6__SWIG_0(self, args);
}
}
if (argc == 1) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__VecT_double_6_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Vec_double_6__SWIG_1(self, args);
}
}
if (argc == 1) {
int _v;
int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Vec_double_6__SWIG_4(self, args);
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_double_6_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_double_6_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_SubOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Vec_double_6__SWIG_3(self, args);
}
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_cv__MatxT_double_6_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_cv__MatxT_double_6_1_t, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_cv__Matx_AddOp, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new__Vec_double_6__SWIG_2(self, args);
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new__Vec_double_6'.\n"
" Possible C/C++ prototypes are:\n"
" cv::Vec< double,6 >::Vec(double const *)\n"
" cv::Vec< double,6 >::Vec(cv::Vec< double,6 > const &)\n"
" cv::Vec< double,6 >::Vec(cv::Matx< double,6,1 > const &,cv::Matx< double,6,1 > const &,cv::Matx_AddOp)\n"
" cv::Vec< double,6 >::Vec(cv::Matx< double,6,1 > const &,cv::Matx< double,6,1 > const &,cv::Matx_SubOp)\n"
" cv::Vec< double,6 >::Vec(std::vector< cv::Vec< double,6 >::value_type,std::allocator< cv::Vec< double,6 >::value_type > >)\n");
return 0;
}
SWIGINTERN PyObject *_wrap__Vec_double_6___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Vec< double,6 > *arg1 = (cv::Vec< double,6 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
std::string result;
if (!PyArg_ParseTuple(args,(char *)"O:_Vec_double_6___str__",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__VecT_double_6_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_Vec_double_6___str__" "', argument " "1"" of type '" "cv::Vec< double,6 > *""'");
}
arg1 = reinterpret_cast< cv::Vec< double,6 > * >(argp1);
result = cv_Vec_Sl_double_Sc_6_Sg____str__(arg1);
resultobj = SWIG_From_std_string(static_cast< std::string >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete__Vec_double_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::Vec< double,6 > *arg1 = (cv::Vec< double,6 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete__Vec_double_6",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__VecT_double_6_t, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__Vec_double_6" "', argument " "1"" of type '" "cv::Vec< double,6 > *""'");
}
arg1 = reinterpret_cast< cv::Vec< double,6 > * >(argp1);
delete arg1;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_Vec_double_6_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_cv__VecT_double_6_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_new__DataType_Vec_double_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::DataType< cv::Vec< double,6 > > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new__DataType_Vec_double_6")) SWIG_fail;
result = (cv::DataType< cv::Vec< double,6 > > *)new cv::DataType< cv::Vec< double,6 > >();
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cv__DataTypeT_cv__VecT_double_6_t_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete__DataType_Vec_double_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cv::DataType< cv::Vec< double,6 > > *arg1 = (cv::DataType< cv::Vec< double,6 > > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete__DataType_Vec_double_6",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cv__DataTypeT_cv__VecT_double_6_t_t, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__DataType_Vec_double_6" "', argument " "1"" of type '" "cv::DataType< cv::Vec< double,6 > > *""'");
}
arg1 = reinterpret_cast< cv::DataType< cv::Vec< double,6 > > * >(argp1);
delete arg1;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_DataType_Vec_double_6_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_cv__DataTypeT_cv__VecT_double_6_t_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_new__mat__np_array_constructor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
_mat__np_array_constructor *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new__mat__np_array_constructor")) SWIG_fail;
result = (_mat__np_array_constructor *)new _mat__np_array_constructor();
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__mat__np_array_constructor, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete__mat__np_array_constructor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
_mat__np_array_constructor *arg1 = (_mat__np_array_constructor *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete__mat__np_array_constructor",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__mat__np_array_constructor, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__mat__np_array_constructor" "', argument " "1"" of type '" "_mat__np_array_constructor *""'");
}
arg1 = reinterpret_cast< _mat__np_array_constructor * >(argp1);
delete arg1;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_mat__np_array_constructor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p__mat__np_array_constructor, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap__depthToDtype(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:_depthToDtype",&obj0)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_depthToDtype" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
result = (char *)_depthToDtype(arg1);
resultobj = SWIG_FromCharPtr((const char *)result);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap__toCvType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::string *arg1 = 0 ;
int arg2 ;
int res1 = SWIG_OLDOBJ ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"OO:_toCvType",&obj0,&obj1)) SWIG_fail;
{
std::string *ptr = (std::string *)0;
res1 = SWIG_AsPtr_std_string(obj0, &ptr);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_toCvType" "', argument " "1"" of type '" "std::string const &""'");
}
if (!ptr) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_toCvType" "', argument " "1"" of type '" "std::string const &""'");
}
arg1 = ptr;
}
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_toCvType" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
result = (int)_toCvType((std::string const &)*arg1,arg2);
resultobj = SWIG_From_int(static_cast< int >(result));
if (SWIG_IsNewObj(res1)) delete arg1;
return resultobj;
fail:
if (SWIG_IsNewObj(res1)) delete arg1;
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_Tracker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
Tracker *arg1 = (Tracker *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_Tracker",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Tracker, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Tracker" "', argument " "1"" of type '" "Tracker *""'");
}
arg1 = reinterpret_cast< Tracker * >(argp1);
delete arg1;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Tracker_init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
Tracker *arg1 = (Tracker *) 0 ;
cv::Rect *arg2 = 0 ;
cv::Mat 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 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:Tracker_init",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Tracker, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tracker_init" "', argument " "1"" of type '" "Tracker *""'");
}
arg1 = reinterpret_cast< Tracker * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__Rect_T_int_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Tracker_init" "', argument " "2"" of type '" "cv::Rect const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Tracker_init" "', argument " "2"" of type '" "cv::Rect const &""'");
}
arg2 = reinterpret_cast< cv::Rect * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Mat, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Tracker_init" "', argument " "3"" of type '" "cv::Mat""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Tracker_init" "', argument " "3"" of type '" "cv::Mat""'");
} else {
cv::Mat * temp = reinterpret_cast< cv::Mat * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
(arg1)->init((cv::Rect const &)*arg2,arg3);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Tracker_update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
Tracker *arg1 = (Tracker *) 0 ;
cv::Mat arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
SwigValueWrapper< cv::Rect_< int > > result;
if (!PyArg_ParseTuple(args,(char *)"OO:Tracker_update",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Tracker, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tracker_update" "', argument " "1"" of type '" "Tracker *""'");
}
arg1 = reinterpret_cast< Tracker * >(argp1);
{
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__Mat, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Tracker_update" "', argument " "2"" of type '" "cv::Mat""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Tracker_update" "', argument " "2"" of type '" "cv::Mat""'");
} else {
cv::Mat * temp = reinterpret_cast< cv::Mat * >(argp2);
arg2 = *temp;
if (SWIG_IsNewObj(res2)) delete temp;
}
}
result = (arg1)->update(arg2);
resultobj = SWIG_NewPointerObj((new cv::Rect(static_cast< const cv::Rect& >(result))), SWIGTYPE_p_cv__Rect_T_int_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *Tracker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_Tracker, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *MAX_FILELEN_swigconstant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *module;
PyObject *d;
if (!PyArg_ParseTuple(args,(char*)"O:swigconstant", &module)) return NULL;
d = PyModule_GetDict(module);
if (!d) return NULL;
SWIG_Python_SetConstant(d, "MAX_FILELEN",SWIG_From_int(static_cast< int >(1024)));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_sPerfProfileParam_cSrcFile0_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
sPerfProfileParam *arg1 = (sPerfProfileParam *) 0 ;
char *arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
char temp2[1024] ;
int res2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:sPerfProfileParam_cSrcFile0_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_sPerfProfileParam, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sPerfProfileParam_cSrcFile0_set" "', argument " "1"" of type '" "sPerfProfileParam *""'");
}
arg1 = reinterpret_cast< sPerfProfileParam * >(argp1);
res2 = SWIG_AsCharArray(obj1, temp2, 1024);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "sPerfProfileParam_cSrcFile0_set" "', argument " "2"" of type '" "char [1024]""'");
}
arg2 = reinterpret_cast< char * >(temp2);
if (arg2) memcpy(arg1->cSrcFile0,arg2,1024*sizeof(char));
else memset(arg1->cSrcFile0,0,1024*sizeof(char));
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_sPerfProfileParam_cSrcFile0_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
sPerfProfileParam *arg1 = (sPerfProfileParam *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
char *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:sPerfProfileParam_cSrcFile0_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_sPerfProfileParam, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sPerfProfileParam_cSrcFile0_get" "', argument " "1"" of type '" "sPerfProfileParam *""'");
}
arg1 = reinterpret_cast< sPerfProfileParam * >(argp1);
result = (char *)(char *) ((arg1)->cSrcFile0);
{
size_t size = SWIG_strnlen(result, 1024);
resultobj = SWIG_FromCharPtrAndSize(result, size);
}
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_sPerfProfileParam_cSrcFile1_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
sPerfProfileParam *arg1 = (sPerfProfileParam *) 0 ;
char *arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
char temp2[1024] ;
int res2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:sPerfProfileParam_cSrcFile1_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_sPerfProfileParam, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sPerfProfileParam_cSrcFile1_set" "', argument " "1"" of type '" "sPerfProfileParam *""'");
}
arg1 = reinterpret_cast< sPerfProfileParam * >(argp1);
res2 = SWIG_AsCharArray(obj1, temp2, 1024);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "sPerfProfileParam_cSrcFile1_set" "', argument " "2"" of type '" "char [1024]""'");
}
arg2 = reinterpret_cast< char * >(temp2);
if (arg2) memcpy(arg1->cSrcFile1,arg2,1024*sizeof(char));
else memset(arg1->cSrcFile1,0,1024*sizeof(char));
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_sPerfProfileParam_cSrcFile1_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
sPerfProfileParam *arg1 = (sPerfProfileParam *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
char *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:sPerfProfileParam_cSrcFile1_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_sPerfProfileParam, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sPerfProfileParam_cSrcFile1_get" "', argument " "1"" of type '" "sPerfProfileParam *""'");
}
arg1 = reinterpret_cast< sPerfProfileParam * >(argp1);
result = (char *)(char *) ((arg1)->cSrcFile1);
{
size_t size = SWIG_strnlen(result, 1024);
resultobj = SWIG_FromCharPtrAndSize(result, size);
}
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_sPerfProfileParam_cParamFile_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
sPerfProfileParam *arg1 = (sPerfProfileParam *) 0 ;
char *arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
char temp2[1024] ;
int res2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:sPerfProfileParam_cParamFile_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_sPerfProfileParam, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sPerfProfileParam_cParamFile_set" "', argument " "1"" of type '" "sPerfProfileParam *""'");
}
arg1 = reinterpret_cast< sPerfProfileParam * >(argp1);
res2 = SWIG_AsCharArray(obj1, temp2, 1024);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "sPerfProfileParam_cParamFile_set" "', argument " "2"" of type '" "char [1024]""'");
}
arg2 = reinterpret_cast< char * >(temp2);
if (arg2) memcpy(arg1->cParamFile,arg2,1024*sizeof(char));
else memset(arg1->cParamFile,0,1024*sizeof(char));
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_sPerfProfileParam_cParamFile_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
sPerfProfileParam *arg1 = (sPerfProfileParam *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
char *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:sPerfProfileParam_cParamFile_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_sPerfProfileParam, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sPerfProfileParam_cParamFile_get" "', argument " "1"" of type '" "sPerfProfileParam *""'");
}
arg1 = reinterpret_cast< sPerfProfileParam * >(argp1);
result = (char *)(char *) ((arg1)->cParamFile);
{
size_t size = SWIG_strnlen(result, 1024);
resultobj = SWIG_FromCharPtrAndSize(result, size);
}
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_sPerfProfileParam_cOutFileH0_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
sPerfProfileParam *arg1 = (sPerfProfileParam *) 0 ;
char *arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
char temp2[1024] ;
int res2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:sPerfProfileParam_cOutFileH0_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_sPerfProfileParam, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sPerfProfileParam_cOutFileH0_set" "', argument " "1"" of type '" "sPerfProfileParam *""'");
}
arg1 = reinterpret_cast< sPerfProfileParam * >(argp1);
res2 = SWIG_AsCharArray(obj1, temp2, 1024);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "sPerfProfileParam_cOutFileH0_set" "', argument " "2"" of type '" "char [1024]""'");
}
arg2 = reinterpret_cast< char * >(temp2);
if (arg2) memcpy(arg1->cOutFileH0,arg2,1024*sizeof(char));
else memset(arg1->cOutFileH0,0,1024*sizeof(char));
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_sPerfProfileParam_cOutFileH0_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
sPerfProfileParam *arg1 = (sPerfProfileParam *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
char *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:sPerfProfileParam_cOutFileH0_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_sPerfProfileParam, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sPerfProfileParam_cOutFileH0_get" "', argument " "1"" of type '" "sPerfProfileParam *""'");
}
arg1 = reinterpret_cast< sPerfProfileParam * >(argp1);
result = (char *)(char *) ((arg1)->cOutFileH0);
{
size_t size = SWIG_strnlen(result, 1024);
resultobj = SWIG_FromCharPtrAndSize(result, size);
}
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_sPerfProfileParam_cOutFileV0_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
sPerfProfileParam *arg1 = (sPerfProfileParam *) 0 ;
char *arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
char temp2[1024] ;
int res2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:sPerfProfileParam_cOutFileV0_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_sPerfProfileParam, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sPerfProfileParam_cOutFileV0_set" "', argument " "1"" of type '" "sPerfProfileParam *""'");
}
arg1 = reinterpret_cast< sPerfProfileParam * >(argp1);
res2 = SWIG_AsCharArray(obj1, temp2, 1024);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "sPerfProfileParam_cOutFileV0_set" "', argument " "2"" of type '" "char [1024]""'");
}
arg2 = reinterpret_cast< char * >(temp2);
if (arg2) memcpy(arg1->cOutFileV0,arg2,1024*sizeof(char));
else memset(arg1->cOutFileV0,0,1024*sizeof(char));
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_sPerfProfileParam_cOutFileV0_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
sPerfProfileParam *arg1 = (sPerfProfileParam *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
char *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:sPerfProfileParam_cOutFileV0_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_sPerfProfileParam, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sPerfProfileParam_cOutFileV0_get" "', argument " "1"" of type '" "sPerfProfileParam *""'");
}
arg1 = reinterpret_cast< sPerfProfileParam * >(argp1);
result = (char *)(char *) ((arg1)->cOutFileV0);
{
size_t size = SWIG_strnlen(result, 1024);
resultobj = SWIG_FromCharPtrAndSize(result, size);
}
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_sPerfProfileParam_cOutFileH1_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
sPerfProfileParam *arg1 = (sPerfProfileParam *) 0 ;
char *arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
char temp2[1024] ;
int res2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:sPerfProfileParam_cOutFileH1_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_sPerfProfileParam, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sPerfProfileParam_cOutFileH1_set" "', argument " "1"" of type '" "sPerfProfileParam *""'");
}
arg1 = reinterpret_cast< sPerfProfileParam * >(argp1);
res2 = SWIG_AsCharArray(obj1, temp2, 1024);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "sPerfProfileParam_cOutFileH1_set" "', argument " "2"" of type '" "char [1024]""'");
}
arg2 = reinterpret_cast< char * >(temp2);
if (arg2) memcpy(arg1->cOutFileH1,arg2,1024*sizeof(char));
else memset(arg1->cOutFileH1,0,1024*sizeof(char));
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_sPerfProfileParam_cOutFileH1_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
sPerfProfileParam *arg1 = (sPerfProfileParam *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
char *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:sPerfProfileParam_cOutFileH1_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_sPerfProfileParam, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sPerfProfileParam_cOutFileH1_get" "', argument " "1"" of type '" "sPerfProfileParam *""'");
}
arg1 = reinterpret_cast< sPerfProfileParam * >(argp1);
result = (char *)(char *) ((arg1)->cOutFileH1);
{
size_t size = SWIG_strnlen(result, 1024);
resultobj = SWIG_FromCharPtrAndSize(result, size);
}
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_sPerfProfileParam_cOutFileV1_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
sPerfProfileParam *arg1 = (sPerfProfileParam *) 0 ;
char *arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
char temp2[1024] ;
int res2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:sPerfProfileParam_cOutFileV1_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_sPerfProfileParam, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sPerfProfileParam_cOutFileV1_set" "', argument " "1"" of type '" "sPerfProfileParam *""'");
}
arg1 = reinterpret_cast< sPerfProfileParam * >(argp1);
res2 = SWIG_AsCharArray(obj1, temp2, 1024);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "sPerfProfileParam_cOutFileV1_set" "', argument " "2"" of type '" "char [1024]""'");
}
arg2 = reinterpret_cast< char * >(temp2);
if (arg2) memcpy(arg1->cOutFileV1,arg2,1024*sizeof(char));
else memset(arg1->cOutFileV1,0,1024*sizeof(char));
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_sPerfProfileParam_cOutFileV1_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
sPerfProfileParam *arg1 = (sPerfProfileParam *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
char *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:sPerfProfileParam_cOutFileV1_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_sPerfProfileParam, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sPerfProfileParam_cOutFileV1_get" "', argument " "1"" of type '" "sPerfProfileParam *""'");
}
arg1 = reinterpret_cast< sPerfProfileParam * >(argp1);
result = (char *)(char *) ((arg1)->cOutFileV1);
{
size_t size = SWIG_strnlen(result, 1024);
resultobj = SWIG_FromCharPtrAndSize(result, size);
}
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_sPerfProfileParam_cOutFileMulSpec_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
sPerfProfileParam *arg1 = (sPerfProfileParam *) 0 ;
char *arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
char temp2[1024] ;
int res2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:sPerfProfileParam_cOutFileMulSpec_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_sPerfProfileParam, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sPerfProfileParam_cOutFileMulSpec_set" "', argument " "1"" of type '" "sPerfProfileParam *""'");
}
arg1 = reinterpret_cast< sPerfProfileParam * >(argp1);
res2 = SWIG_AsCharArray(obj1, temp2, 1024);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "sPerfProfileParam_cOutFileMulSpec_set" "', argument " "2"" of type '" "char [1024]""'");
}
arg2 = reinterpret_cast< char * >(temp2);
if (arg2) memcpy(arg1->cOutFileMulSpec,arg2,1024*sizeof(char));
else memset(arg1->cOutFileMulSpec,0,1024*sizeof(char));
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_sPerfProfileParam_cOutFileMulSpec_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
sPerfProfileParam *arg1 = (sPerfProfileParam *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
char *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:sPerfProfileParam_cOutFileMulSpec_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_sPerfProfileParam, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sPerfProfileParam_cOutFileMulSpec_get" "', argument " "1"" of type '" "sPerfProfileParam *""'");
}
arg1 = reinterpret_cast< sPerfProfileParam * >(argp1);
result = (char *)(char *) ((arg1)->cOutFileMulSpec);
{
size_t size = SWIG_strnlen(result, 1024);
resultobj = SWIG_FromCharPtrAndSize(result, size);
}
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_sPerfProfileParam_cOutDFTInvH_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
sPerfProfileParam *arg1 = (sPerfProfileParam *) 0 ;
char *arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
char temp2[1024] ;
int res2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:sPerfProfileParam_cOutDFTInvH_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_sPerfProfileParam, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sPerfProfileParam_cOutDFTInvH_set" "', argument " "1"" of type '" "sPerfProfileParam *""'");
}
arg1 = reinterpret_cast< sPerfProfileParam * >(argp1);
res2 = SWIG_AsCharArray(obj1, temp2, 1024);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "sPerfProfileParam_cOutDFTInvH_set" "', argument " "2"" of type '" "char [1024]""'");
}
arg2 = reinterpret_cast< char * >(temp2);
if (arg2) memcpy(arg1->cOutDFTInvH,arg2,1024*sizeof(char));
else memset(arg1->cOutDFTInvH,0,1024*sizeof(char));
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_sPerfProfileParam_cOutDFTInvH_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
sPerfProfileParam *arg1 = (sPerfProfileParam *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
char *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:sPerfProfileParam_cOutDFTInvH_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_sPerfProfileParam, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sPerfProfileParam_cOutDFTInvH_get" "', argument " "1"" of type '" "sPerfProfileParam *""'");
}
arg1 = reinterpret_cast< sPerfProfileParam * >(argp1);
result = (char *)(char *) ((arg1)->cOutDFTInvH);
{
size_t size = SWIG_strnlen(result, 1024);
resultobj = SWIG_FromCharPtrAndSize(result, size);
}
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_sPerfProfileParam_cOutDFTInvV_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
sPerfProfileParam *arg1 = (sPerfProfileParam *) 0 ;
char *arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
char temp2[1024] ;
int res2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:sPerfProfileParam_cOutDFTInvV_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_sPerfProfileParam, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sPerfProfileParam_cOutDFTInvV_set" "', argument " "1"" of type '" "sPerfProfileParam *""'");
}
arg1 = reinterpret_cast< sPerfProfileParam * >(argp1);
res2 = SWIG_AsCharArray(obj1, temp2, 1024);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "sPerfProfileParam_cOutDFTInvV_set" "', argument " "2"" of type '" "char [1024]""'");
}
arg2 = reinterpret_cast< char * >(temp2);
if (arg2) memcpy(arg1->cOutDFTInvV,arg2,1024*sizeof(char));
else memset(arg1->cOutDFTInvV,0,1024*sizeof(char));
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_sPerfProfileParam_cOutDFTInvV_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
sPerfProfileParam *arg1 = (sPerfProfileParam *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
char *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:sPerfProfileParam_cOutDFTInvV_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_sPerfProfileParam, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sPerfProfileParam_cOutDFTInvV_get" "', argument " "1"" of type '" "sPerfProfileParam *""'");
}
arg1 = reinterpret_cast< sPerfProfileParam * >(argp1);
result = (char *)(char *) ((arg1)->cOutDFTInvV);
{
size_t size = SWIG_strnlen(result, 1024);
resultobj = SWIG_FromCharPtrAndSize(result, size);
}
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_sPerfProfileParam_cOutImageSum_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
sPerfProfileParam *arg1 = (sPerfProfileParam *) 0 ;
char *arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
char temp2[1024] ;
int res2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:sPerfProfileParam_cOutImageSum_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_sPerfProfileParam, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sPerfProfileParam_cOutImageSum_set" "', argument " "1"" of type '" "sPerfProfileParam *""'");
}
arg1 = reinterpret_cast< sPerfProfileParam * >(argp1);
res2 = SWIG_AsCharArray(obj1, temp2, 1024);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "sPerfProfileParam_cOutImageSum_set" "', argument " "2"" of type '" "char [1024]""'");
}
arg2 = reinterpret_cast< char * >(temp2);
if (arg2) memcpy(arg1->cOutImageSum,arg2,1024*sizeof(char));
else memset(arg1->cOutImageSum,0,1024*sizeof(char));
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_sPerfProfileParam_cOutImageSum_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
sPerfProfileParam *arg1 = (sPerfProfileParam *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
char *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:sPerfProfileParam_cOutImageSum_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_sPerfProfileParam, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sPerfProfileParam_cOutImageSum_get" "', argument " "1"" of type '" "sPerfProfileParam *""'");
}
arg1 = reinterpret_cast< sPerfProfileParam * >(argp1);
result = (char *)(char *) ((arg1)->cOutImageSum);
{
size_t size = SWIG_strnlen(result, 1024);
resultobj = SWIG_FromCharPtrAndSize(result, size);
}
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_sPerfProfileParam_cOutSrcImageSum_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
sPerfProfileParam *arg1 = (sPerfProfileParam *) 0 ;
char *arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
char temp2[1024] ;
int res2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:sPerfProfileParam_cOutSrcImageSum_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_sPerfProfileParam, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sPerfProfileParam_cOutSrcImageSum_set" "', argument " "1"" of type '" "sPerfProfileParam *""'");
}
arg1 = reinterpret_cast< sPerfProfileParam * >(argp1);
res2 = SWIG_AsCharArray(obj1, temp2, 1024);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "sPerfProfileParam_cOutSrcImageSum_set" "', argument " "2"" of type '" "char [1024]""'");
}
arg2 = reinterpret_cast< char * >(temp2);
if (arg2) memcpy(arg1->cOutSrcImageSum,arg2,1024*sizeof(char));
else memset(arg1->cOutSrcImageSum,0,1024*sizeof(char));
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_sPerfProfileParam_cOutSrcImageSum_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
sPerfProfileParam *arg1 = (sPerfProfileParam *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
char *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:sPerfProfileParam_cOutSrcImageSum_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_sPerfProfileParam, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sPerfProfileParam_cOutSrcImageSum_get" "', argument " "1"" of type '" "sPerfProfileParam *""'");
}
arg1 = reinterpret_cast< sPerfProfileParam * >(argp1);
result = (char *)(char *) ((arg1)->cOutSrcImageSum);
{
size_t size = SWIG_strnlen(result, 1024);
resultobj = SWIG_FromCharPtrAndSize(result, size);
}
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_sPerfProfileParam_cOutFinal_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
sPerfProfileParam *arg1 = (sPerfProfileParam *) 0 ;
char *arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
char temp2[1024] ;
int res2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:sPerfProfileParam_cOutFinal_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_sPerfProfileParam, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sPerfProfileParam_cOutFinal_set" "', argument " "1"" of type '" "sPerfProfileParam *""'");
}
arg1 = reinterpret_cast< sPerfProfileParam * >(argp1);
res2 = SWIG_AsCharArray(obj1, temp2, 1024);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "sPerfProfileParam_cOutFinal_set" "', argument " "2"" of type '" "char [1024]""'");
}
arg2 = reinterpret_cast< char * >(temp2);
if (arg2) memcpy(arg1->cOutFinal,arg2,1024*sizeof(char));
else memset(arg1->cOutFinal,0,1024*sizeof(char));
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_sPerfProfileParam_cOutFinal_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
sPerfProfileParam *arg1 = (sPerfProfileParam *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
char *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:sPerfProfileParam_cOutFinal_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_sPerfProfileParam, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sPerfProfileParam_cOutFinal_get" "', argument " "1"" of type '" "sPerfProfileParam *""'");
}
arg1 = reinterpret_cast< sPerfProfileParam * >(argp1);
result = (char *)(char *) ((arg1)->cOutFinal);
{
size_t size = SWIG_strnlen(result, 1024);
resultobj = SWIG_FromCharPtrAndSize(result, size);
}
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_sPerfProfileParam_usInWidth_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
sPerfProfileParam *arg1 = (sPerfProfileParam *) 0 ;
unsigned short arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
unsigned short val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:sPerfProfileParam_usInWidth_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_sPerfProfileParam, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sPerfProfileParam_usInWidth_set" "', argument " "1"" of type '" "sPerfProfileParam *""'");
}
arg1 = reinterpret_cast< sPerfProfileParam * >(argp1);
ecode2 = SWIG_AsVal_unsigned_SS_short(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "sPerfProfileParam_usInWidth_set" "', argument " "2"" of type '" "unsigned short""'");
}
arg2 = static_cast< unsigned short >(val2);
if (arg1) (arg1)->usInWidth = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_sPerfProfileParam_usInWidth_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
sPerfProfileParam *arg1 = (sPerfProfileParam *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
unsigned short result;
if (!PyArg_ParseTuple(args,(char *)"O:sPerfProfileParam_usInWidth_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_sPerfProfileParam, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sPerfProfileParam_usInWidth_get" "', argument " "1"" of type '" "sPerfProfileParam *""'");
}
arg1 = reinterpret_cast< sPerfProfileParam * >(argp1);
result = (unsigned short) ((arg1)->usInWidth);
resultobj = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_sPerfProfileParam_usInHeight_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
sPerfProfileParam *arg1 = (sPerfProfileParam *) 0 ;
unsigned short arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
unsigned short val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:sPerfProfileParam_usInHeight_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_sPerfProfileParam, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sPerfProfileParam_usInHeight_set" "', argument " "1"" of type '" "sPerfProfileParam *""'");
}
arg1 = reinterpret_cast< sPerfProfileParam * >(argp1);
ecode2 = SWIG_AsVal_unsigned_SS_short(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "sPerfProfileParam_usInHeight_set" "', argument " "2"" of type '" "unsigned short""'");
}
arg2 = static_cast< unsigned short >(val2);
if (arg1) (arg1)->usInHeight = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_sPerfProfileParam_usInHeight_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
sPerfProfileParam *arg1 = (sPerfProfileParam *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
unsigned short result;
if (!PyArg_ParseTuple(args,(char *)"O:sPerfProfileParam_usInHeight_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_sPerfProfileParam, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sPerfProfileParam_usInHeight_get" "', argument " "1"" of type '" "sPerfProfileParam *""'");
}
arg1 = reinterpret_cast< sPerfProfileParam * >(argp1);
result = (unsigned short) ((arg1)->usInHeight);
resultobj = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_sPerfProfileParam_ucInFormat_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
sPerfProfileParam *arg1 = (sPerfProfileParam *) 0 ;
unsigned short arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
unsigned short val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:sPerfProfileParam_ucInFormat_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_sPerfProfileParam, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sPerfProfileParam_ucInFormat_set" "', argument " "1"" of type '" "sPerfProfileParam *""'");
}
arg1 = reinterpret_cast< sPerfProfileParam * >(argp1);
ecode2 = SWIG_AsVal_unsigned_SS_short(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "sPerfProfileParam_ucInFormat_set" "', argument " "2"" of type '" "unsigned short""'");
}
arg2 = static_cast< unsigned short >(val2);
if (arg1) (arg1)->ucInFormat = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_sPerfProfileParam_ucInFormat_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
sPerfProfileParam *arg1 = (sPerfProfileParam *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
unsigned short result;
if (!PyArg_ParseTuple(args,(char *)"O:sPerfProfileParam_ucInFormat_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_sPerfProfileParam, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sPerfProfileParam_ucInFormat_get" "', argument " "1"" of type '" "sPerfProfileParam *""'");
}
arg1 = reinterpret_cast< sPerfProfileParam * >(argp1);
result = (unsigned short) ((arg1)->ucInFormat);
resultobj = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_sPerfProfileParam_usOutWidth_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
sPerfProfileParam *arg1 = (sPerfProfileParam *) 0 ;
unsigned short arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
unsigned short val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:sPerfProfileParam_usOutWidth_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_sPerfProfileParam, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sPerfProfileParam_usOutWidth_set" "', argument " "1"" of type '" "sPerfProfileParam *""'");
}
arg1 = reinterpret_cast< sPerfProfileParam * >(argp1);
ecode2 = SWIG_AsVal_unsigned_SS_short(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "sPerfProfileParam_usOutWidth_set" "', argument " "2"" of type '" "unsigned short""'");
}
arg2 = static_cast< unsigned short >(val2);
if (arg1) (arg1)->usOutWidth = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_sPerfProfileParam_usOutWidth_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
sPerfProfileParam *arg1 = (sPerfProfileParam *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
unsigned short result;
if (!PyArg_ParseTuple(args,(char *)"O:sPerfProfileParam_usOutWidth_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_sPerfProfileParam, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sPerfProfileParam_usOutWidth_get" "', argument " "1"" of type '" "sPerfProfileParam *""'");
}
arg1 = reinterpret_cast< sPerfProfileParam * >(argp1);
result = (unsigned short) ((arg1)->usOutWidth);
resultobj = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_sPerfProfileParam_usOutHeight_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
sPerfProfileParam *arg1 = (sPerfProfileParam *) 0 ;
unsigned short arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
unsigned short val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:sPerfProfileParam_usOutHeight_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_sPerfProfileParam, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sPerfProfileParam_usOutHeight_set" "', argument " "1"" of type '" "sPerfProfileParam *""'");
}
arg1 = reinterpret_cast< sPerfProfileParam * >(argp1);
ecode2 = SWIG_AsVal_unsigned_SS_short(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "sPerfProfileParam_usOutHeight_set" "', argument " "2"" of type '" "unsigned short""'");
}
arg2 = static_cast< unsigned short >(val2);
if (arg1) (arg1)->usOutHeight = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_sPerfProfileParam_usOutHeight_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
sPerfProfileParam *arg1 = (sPerfProfileParam *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
unsigned short result;
if (!PyArg_ParseTuple(args,(char *)"O:sPerfProfileParam_usOutHeight_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_sPerfProfileParam, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sPerfProfileParam_usOutHeight_get" "', argument " "1"" of type '" "sPerfProfileParam *""'");
}
arg1 = reinterpret_cast< sPerfProfileParam * >(argp1);
result = (unsigned short) ((arg1)->usOutHeight);
resultobj = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_sPerfProfileParam_usOutFormat_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
sPerfProfileParam *arg1 = (sPerfProfileParam *) 0 ;
unsigned short arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
unsigned short val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:sPerfProfileParam_usOutFormat_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_sPerfProfileParam, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sPerfProfileParam_usOutFormat_set" "', argument " "1"" of type '" "sPerfProfileParam *""'");
}
arg1 = reinterpret_cast< sPerfProfileParam * >(argp1);
ecode2 = SWIG_AsVal_unsigned_SS_short(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "sPerfProfileParam_usOutFormat_set" "', argument " "2"" of type '" "unsigned short""'");
}
arg2 = static_cast< unsigned short >(val2);
if (arg1) (arg1)->usOutFormat = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_sPerfProfileParam_usOutFormat_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
sPerfProfileParam *arg1 = (sPerfProfileParam *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
unsigned short result;
if (!PyArg_ParseTuple(args,(char *)"O:sPerfProfileParam_usOutFormat_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_sPerfProfileParam, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sPerfProfileParam_usOutFormat_get" "', argument " "1"" of type '" "sPerfProfileParam *""'");
}
arg1 = reinterpret_cast< sPerfProfileParam * >(argp1);
result = (unsigned short) ((arg1)->usOutFormat);
resultobj = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_sPerfProfileParam_usSliceNum_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
sPerfProfileParam *arg1 = (sPerfProfileParam *) 0 ;
unsigned short arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
unsigned short val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:sPerfProfileParam_usSliceNum_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_sPerfProfileParam, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sPerfProfileParam_usSliceNum_set" "', argument " "1"" of type '" "sPerfProfileParam *""'");
}
arg1 = reinterpret_cast< sPerfProfileParam * >(argp1);
ecode2 = SWIG_AsVal_unsigned_SS_short(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "sPerfProfileParam_usSliceNum_set" "', argument " "2"" of type '" "unsigned short""'");
}
arg2 = static_cast< unsigned short >(val2);
if (arg1) (arg1)->usSliceNum = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_sPerfProfileParam_usSliceNum_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
sPerfProfileParam *arg1 = (sPerfProfileParam *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
unsigned short result;
if (!PyArg_ParseTuple(args,(char *)"O:sPerfProfileParam_usSliceNum_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_sPerfProfileParam, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sPerfProfileParam_usSliceNum_get" "', argument " "1"" of type '" "sPerfProfileParam *""'");
}
arg1 = reinterpret_cast< sPerfProfileParam * >(argp1);
result = (unsigned short) ((arg1)->usSliceNum);
resultobj = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_sPerfProfileParam_usSubSliceNum_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
sPerfProfileParam *arg1 = (sPerfProfileParam *) 0 ;
unsigned short arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
unsigned short val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:sPerfProfileParam_usSubSliceNum_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_sPerfProfileParam, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sPerfProfileParam_usSubSliceNum_set" "', argument " "1"" of type '" "sPerfProfileParam *""'");
}
arg1 = reinterpret_cast< sPerfProfileParam * >(argp1);
ecode2 = SWIG_AsVal_unsigned_SS_short(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "sPerfProfileParam_usSubSliceNum_set" "', argument " "2"" of type '" "unsigned short""'");
}
arg2 = static_cast< unsigned short >(val2);
if (arg1) (arg1)->usSubSliceNum = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_sPerfProfileParam_usSubSliceNum_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
sPerfProfileParam *arg1 = (sPerfProfileParam *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
unsigned short result;
if (!PyArg_ParseTuple(args,(char *)"O:sPerfProfileParam_usSubSliceNum_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_sPerfProfileParam, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sPerfProfileParam_usSubSliceNum_get" "', argument " "1"" of type '" "sPerfProfileParam *""'");
}
arg1 = reinterpret_cast< sPerfProfileParam * >(argp1);
result = (unsigned short) ((arg1)->usSubSliceNum);
resultobj = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_sPerfProfileParam_usEUNum_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
sPerfProfileParam *arg1 = (sPerfProfileParam *) 0 ;
unsigned short arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
unsigned short val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:sPerfProfileParam_usEUNum_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_sPerfProfileParam, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sPerfProfileParam_usEUNum_set" "', argument " "1"" of type '" "sPerfProfileParam *""'");
}
arg1 = reinterpret_cast< sPerfProfileParam * >(argp1);
ecode2 = SWIG_AsVal_unsigned_SS_short(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "sPerfProfileParam_usEUNum_set" "', argument " "2"" of type '" "unsigned short""'");
}
arg2 = static_cast< unsigned short >(val2);
if (arg1) (arg1)->usEUNum = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_sPerfProfileParam_usEUNum_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
sPerfProfileParam *arg1 = (sPerfProfileParam *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
unsigned short result;
if (!PyArg_ParseTuple(args,(char *)"O:sPerfProfileParam_usEUNum_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_sPerfProfileParam, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sPerfProfileParam_usEUNum_get" "', argument " "1"" of type '" "sPerfProfileParam *""'");
}
arg1 = reinterpret_cast< sPerfProfileParam * >(argp1);
result = (unsigned short) ((arg1)->usEUNum);
resultobj = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_sPerfProfileParam_bPrimitive_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
sPerfProfileParam *arg1 = (sPerfProfileParam *) 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:sPerfProfileParam_bPrimitive_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_sPerfProfileParam, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sPerfProfileParam_bPrimitive_set" "', argument " "1"" of type '" "sPerfProfileParam *""'");
}
arg1 = reinterpret_cast< sPerfProfileParam * >(argp1);
ecode2 = SWIG_AsVal_bool(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "sPerfProfileParam_bPrimitive_set" "', argument " "2"" of type '" "bool""'");
}
arg2 = static_cast< bool >(val2);
if (arg1) (arg1)->bPrimitive = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_sPerfProfileParam_bPrimitive_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
sPerfProfileParam *arg1 = (sPerfProfileParam *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
bool result;
if (!PyArg_ParseTuple(args,(char *)"O:sPerfProfileParam_bPrimitive_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_sPerfProfileParam, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sPerfProfileParam_bPrimitive_get" "', argument " "1"" of type '" "sPerfProfileParam *""'");
}
arg1 = reinterpret_cast< sPerfProfileParam * >(argp1);
result = (bool) ((arg1)->bPrimitive);
resultobj = SWIG_From_bool(static_cast< bool >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_sPerfProfileParam_usLoops_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
sPerfProfileParam *arg1 = (sPerfProfileParam *) 0 ;
unsigned short arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
unsigned short val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:sPerfProfileParam_usLoops_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_sPerfProfileParam, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sPerfProfileParam_usLoops_set" "', argument " "1"" of type '" "sPerfProfileParam *""'");
}
arg1 = reinterpret_cast< sPerfProfileParam * >(argp1);
ecode2 = SWIG_AsVal_unsigned_SS_short(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "sPerfProfileParam_usLoops_set" "', argument " "2"" of type '" "unsigned short""'");
}
arg2 = static_cast< unsigned short >(val2);
if (arg1) (arg1)->usLoops = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_sPerfProfileParam_usLoops_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
sPerfProfileParam *arg1 = (sPerfProfileParam *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
unsigned short result;
if (!PyArg_ParseTuple(args,(char *)"O:sPerfProfileParam_usLoops_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_sPerfProfileParam, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sPerfProfileParam_usLoops_get" "', argument " "1"" of type '" "sPerfProfileParam *""'");
}
arg1 = reinterpret_cast< sPerfProfileParam * >(argp1);
result = (unsigned short) ((arg1)->usLoops);
resultobj = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_sPerfProfileParam_usWalkerPattern_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
sPerfProfileParam *arg1 = (sPerfProfileParam *) 0 ;
unsigned short arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
unsigned short val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:sPerfProfileParam_usWalkerPattern_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_sPerfProfileParam, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sPerfProfileParam_usWalkerPattern_set" "', argument " "1"" of type '" "sPerfProfileParam *""'");
}
arg1 = reinterpret_cast< sPerfProfileParam * >(argp1);
ecode2 = SWIG_AsVal_unsigned_SS_short(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "sPerfProfileParam_usWalkerPattern_set" "', argument " "2"" of type '" "unsigned short""'");
}
arg2 = static_cast< unsigned short >(val2);
if (arg1) (arg1)->usWalkerPattern = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_sPerfProfileParam_usWalkerPattern_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
sPerfProfileParam *arg1 = (sPerfProfileParam *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
unsigned short result;
if (!PyArg_ParseTuple(args,(char *)"O:sPerfProfileParam_usWalkerPattern_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_sPerfProfileParam, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sPerfProfileParam_usWalkerPattern_get" "', argument " "1"" of type '" "sPerfProfileParam *""'");
}
arg1 = reinterpret_cast< sPerfProfileParam * >(argp1);
result = (unsigned short) ((arg1)->usWalkerPattern);
resultobj = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_sPerfProfileParam_usPitchX_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
sPerfProfileParam *arg1 = (sPerfProfileParam *) 0 ;
unsigned short arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
unsigned short val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:sPerfProfileParam_usPitchX_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_sPerfProfileParam, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sPerfProfileParam_usPitchX_set" "', argument " "1"" of type '" "sPerfProfileParam *""'");
}
arg1 = reinterpret_cast< sPerfProfileParam * >(argp1);
ecode2 = SWIG_AsVal_unsigned_SS_short(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "sPerfProfileParam_usPitchX_set" "', argument " "2"" of type '" "unsigned short""'");
}
arg2 = static_cast< unsigned short >(val2);
if (arg1) (arg1)->usPitchX = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_sPerfProfileParam_usPitchX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
sPerfProfileParam *arg1 = (sPerfProfileParam *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
unsigned short result;
if (!PyArg_ParseTuple(args,(char *)"O:sPerfProfileParam_usPitchX_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_sPerfProfileParam, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sPerfProfileParam_usPitchX_get" "', argument " "1"" of type '" "sPerfProfileParam *""'");
}
arg1 = reinterpret_cast< sPerfProfileParam * >(argp1);
result = (unsigned short) ((arg1)->usPitchX);
resultobj = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_sPerfProfileParam_usPitchY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
sPerfProfileParam *arg1 = (sPerfProfileParam *) 0 ;
unsigned short arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
unsigned short val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:sPerfProfileParam_usPitchY_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_sPerfProfileParam, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sPerfProfileParam_usPitchY_set" "', argument " "1"" of type '" "sPerfProfileParam *""'");
}
arg1 = reinterpret_cast< sPerfProfileParam * >(argp1);
ecode2 = SWIG_AsVal_unsigned_SS_short(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "sPerfProfileParam_usPitchY_set" "', argument " "2"" of type '" "unsigned short""'");
}
arg2 = static_cast< unsigned short >(val2);
if (arg1) (arg1)->usPitchY = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_sPerfProfileParam_usPitchY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
sPerfProfileParam *arg1 = (sPerfProfileParam *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
unsigned short result;
if (!PyArg_ParseTuple(args,(char *)"O:sPerfProfileParam_usPitchY_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_sPerfProfileParam, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sPerfProfileParam_usPitchY_get" "', argument " "1"" of type '" "sPerfProfileParam *""'");
}
arg1 = reinterpret_cast< sPerfProfileParam * >(argp1);
result = (unsigned short) ((arg1)->usPitchY);
resultobj = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_sPerfProfileParam_usPitchZ_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
sPerfProfileParam *arg1 = (sPerfProfileParam *) 0 ;
unsigned short arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
unsigned short val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:sPerfProfileParam_usPitchZ_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_sPerfProfileParam, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sPerfProfileParam_usPitchZ_set" "', argument " "1"" of type '" "sPerfProfileParam *""'");
}
arg1 = reinterpret_cast< sPerfProfileParam * >(argp1);
ecode2 = SWIG_AsVal_unsigned_SS_short(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "sPerfProfileParam_usPitchZ_set" "', argument " "2"" of type '" "unsigned short""'");
}
arg2 = static_cast< unsigned short >(val2);
if (arg1) (arg1)->usPitchZ = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_sPerfProfileParam_usPitchZ_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
sPerfProfileParam *arg1 = (sPerfProfileParam *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
unsigned short result;
if (!PyArg_ParseTuple(args,(char *)"O:sPerfProfileParam_usPitchZ_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_sPerfProfileParam, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sPerfProfileParam_usPitchZ_get" "', argument " "1"" of type '" "sPerfProfileParam *""'");
}
arg1 = reinterpret_cast< sPerfProfileParam * >(argp1);
result = (unsigned short) ((arg1)->usPitchZ);
resultobj = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_sPerfProfileParam_fScale_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
sPerfProfileParam *arg1 = (sPerfProfileParam *) 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:sPerfProfileParam_fScale_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_sPerfProfileParam, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sPerfProfileParam_fScale_set" "', argument " "1"" of type '" "sPerfProfileParam *""'");
}
arg1 = reinterpret_cast< sPerfProfileParam * >(argp1);
ecode2 = SWIG_AsVal_float(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "sPerfProfileParam_fScale_set" "', argument " "2"" of type '" "float""'");
}
arg2 = static_cast< float >(val2);
if (arg1) (arg1)->fScale = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_sPerfProfileParam_fScale_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
sPerfProfileParam *arg1 = (sPerfProfileParam *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
float result;
if (!PyArg_ParseTuple(args,(char *)"O:sPerfProfileParam_fScale_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_sPerfProfileParam, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sPerfProfileParam_fScale_get" "', argument " "1"" of type '" "sPerfProfileParam *""'");
}
arg1 = reinterpret_cast< sPerfProfileParam * >(argp1);
result = (float) ((arg1)->fScale);
resultobj = SWIG_From_float(static_cast< float >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_sPerfProfileParam_ucChannel_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
sPerfProfileParam *arg1 = (sPerfProfileParam *) 0 ;
unsigned char arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
unsigned char val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:sPerfProfileParam_ucChannel_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_sPerfProfileParam, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sPerfProfileParam_ucChannel_set" "', argument " "1"" of type '" "sPerfProfileParam *""'");
}
arg1 = reinterpret_cast< sPerfProfileParam * >(argp1);
ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "sPerfProfileParam_ucChannel_set" "', argument " "2"" of type '" "unsigned char""'");
}
arg2 = static_cast< unsigned char >(val2);
if (arg1) (arg1)->ucChannel = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_sPerfProfileParam_ucChannel_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
sPerfProfileParam *arg1 = (sPerfProfileParam *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
unsigned char result;
if (!PyArg_ParseTuple(args,(char *)"O:sPerfProfileParam_ucChannel_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_sPerfProfileParam, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sPerfProfileParam_ucChannel_get" "', argument " "1"" of type '" "sPerfProfileParam *""'");
}
arg1 = reinterpret_cast< sPerfProfileParam * >(argp1);
result = (unsigned char) ((arg1)->ucChannel);
resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_sPerfProfileParam_bInv_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
sPerfProfileParam *arg1 = (sPerfProfileParam *) 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:sPerfProfileParam_bInv_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_sPerfProfileParam, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sPerfProfileParam_bInv_set" "', argument " "1"" of type '" "sPerfProfileParam *""'");
}
arg1 = reinterpret_cast< sPerfProfileParam * >(argp1);
ecode2 = SWIG_AsVal_bool(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "sPerfProfileParam_bInv_set" "', argument " "2"" of type '" "bool""'");
}
arg2 = static_cast< bool >(val2);
if (arg1) (arg1)->bInv = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_sPerfProfileParam_bInv_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
sPerfProfileParam *arg1 = (sPerfProfileParam *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
bool result;
if (!PyArg_ParseTuple(args,(char *)"O:sPerfProfileParam_bInv_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_sPerfProfileParam, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sPerfProfileParam_bInv_get" "', argument " "1"" of type '" "sPerfProfileParam *""'");
}
arg1 = reinterpret_cast< sPerfProfileParam * >(argp1);
result = (bool) ((arg1)->bInv);
resultobj = SWIG_From_bool(static_cast< bool >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_sPerfProfileParam(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
sPerfProfileParam *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new_sPerfProfileParam")) SWIG_fail;
result = (sPerfProfileParam *)new sPerfProfileParam();
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sPerfProfileParam, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_sPerfProfileParam(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
sPerfProfileParam *arg1 = (sPerfProfileParam *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_sPerfProfileParam",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_sPerfProfileParam, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_sPerfProfileParam" "', argument " "1"" of type '" "sPerfProfileParam *""'");
}
arg1 = reinterpret_cast< sPerfProfileParam * >(argp1);
delete arg1;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *sPerfProfileParam_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_sPerfProfileParam, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_InputParamMap_token_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
InputParamMap *arg1 = (InputParamMap *) 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:InputParamMap_token_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_InputParamMap, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputParamMap_token_set" "', argument " "1"" of type '" "InputParamMap *""'");
}
arg1 = reinterpret_cast< InputParamMap * >(argp1);
res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InputParamMap_token_set" "', argument " "2"" of type '" "char *""'");
}
arg2 = reinterpret_cast< char * >(buf2);
if (arg1->token) delete[] arg1->token;
if (arg2) {
size_t size = strlen(reinterpret_cast< const char * >(arg2)) + 1;
arg1->token = (char *)reinterpret_cast< char* >(memcpy((new char[size]), reinterpret_cast< const char * >(arg2), sizeof(char)*(size)));
} else {
arg1->token = 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_InputParamMap_token_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
InputParamMap *arg1 = (InputParamMap *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
char *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:InputParamMap_token_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_InputParamMap, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputParamMap_token_get" "', argument " "1"" of type '" "InputParamMap *""'");
}
arg1 = reinterpret_cast< InputParamMap * >(argp1);
result = (char *) ((arg1)->token);
resultobj = SWIG_FromCharPtr((const char *)result);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_InputParamMap_place_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
InputParamMap *arg1 = (InputParamMap *) 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:InputParamMap_place_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_InputParamMap, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputParamMap_place_set" "', argument " "1"" of type '" "InputParamMap *""'");
}
arg1 = reinterpret_cast< InputParamMap * >(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 '" "InputParamMap_place_set" "', argument " "2"" of type '" "void *""'");
}
if (arg1) (arg1)->place = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_InputParamMap_place_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
InputParamMap *arg1 = (InputParamMap *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
void *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:InputParamMap_place_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_InputParamMap, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputParamMap_place_get" "', argument " "1"" of type '" "InputParamMap *""'");
}
arg1 = reinterpret_cast< InputParamMap * >(argp1);
result = (void *) ((arg1)->place);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_InputParamMap_type_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
InputParamMap *arg1 = (InputParamMap *) 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:InputParamMap_type_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_InputParamMap, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputParamMap_type_set" "', argument " "1"" of type '" "InputParamMap *""'");
}
arg1 = reinterpret_cast< InputParamMap * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputParamMap_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_InputParamMap_type_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
InputParamMap *arg1 = (InputParamMap *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:InputParamMap_type_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_InputParamMap, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputParamMap_type_get" "', argument " "1"" of type '" "InputParamMap *""'");
}
arg1 = reinterpret_cast< InputParamMap * >(argp1);
result = (int) ((arg1)->type);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_InputParamMap_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
InputParamMap *arg1 = (InputParamMap *) 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:InputParamMap_size_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_InputParamMap, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputParamMap_size_set" "', argument " "1"" of type '" "InputParamMap *""'");
}
arg1 = reinterpret_cast< InputParamMap * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputParamMap_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_InputParamMap_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
InputParamMap *arg1 = (InputParamMap *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:InputParamMap_size_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_InputParamMap, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputParamMap_size_get" "', argument " "1"" of type '" "InputParamMap *""'");
}
arg1 = reinterpret_cast< InputParamMap * >(argp1);
result = (int) ((arg1)->size);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_InputParamMap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
InputParamMap *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new_InputParamMap")) SWIG_fail;
result = (InputParamMap *)new InputParamMap();
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_InputParamMap, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_InputParamMap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
InputParamMap *arg1 = (InputParamMap *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_InputParamMap",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_InputParamMap, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InputParamMap" "', argument " "1"" of type '" "InputParamMap *""'");
}
arg1 = reinterpret_cast< InputParamMap * >(argp1);
delete arg1;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *InputParamMap_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_InputParamMap, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_new_KCFTracker__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
bool arg1 ;
bool arg2 ;
bool arg3 ;
bool arg4 ;
bool val1 ;
int ecode1 = 0 ;
bool val2 ;
int ecode2 = 0 ;
bool val3 ;
int ecode3 = 0 ;
bool val4 ;
int ecode4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
KCFTracker *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOO:new_KCFTracker",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
ecode1 = SWIG_AsVal_bool(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KCFTracker" "', argument " "1"" of type '" "bool""'");
}
arg1 = static_cast< bool >(val1);
ecode2 = SWIG_AsVal_bool(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_KCFTracker" "', argument " "2"" of type '" "bool""'");
}
arg2 = static_cast< bool >(val2);
ecode3 = SWIG_AsVal_bool(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_KCFTracker" "', argument " "3"" of type '" "bool""'");
}
arg3 = static_cast< bool >(val3);
ecode4 = SWIG_AsVal_bool(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_KCFTracker" "', argument " "4"" of type '" "bool""'");
}
arg4 = static_cast< bool >(val4);
result = (KCFTracker *)new KCFTracker(arg1,arg2,arg3,arg4);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_KCFTracker, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_KCFTracker__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
bool arg1 ;
bool arg2 ;
bool arg3 ;
bool val1 ;
int ecode1 = 0 ;
bool val2 ;
int ecode2 = 0 ;
bool val3 ;
int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
KCFTracker *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new_KCFTracker",&obj0,&obj1,&obj2)) SWIG_fail;
ecode1 = SWIG_AsVal_bool(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KCFTracker" "', argument " "1"" of type '" "bool""'");
}
arg1 = static_cast< bool >(val1);
ecode2 = SWIG_AsVal_bool(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_KCFTracker" "', argument " "2"" of type '" "bool""'");
}
arg2 = static_cast< bool >(val2);
ecode3 = SWIG_AsVal_bool(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_KCFTracker" "', argument " "3"" of type '" "bool""'");
}
arg3 = static_cast< bool >(val3);
result = (KCFTracker *)new KCFTracker(arg1,arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_KCFTracker, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_KCFTracker__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
bool arg1 ;
bool arg2 ;
bool val1 ;
int ecode1 = 0 ;
bool val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
KCFTracker *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:new_KCFTracker",&obj0,&obj1)) SWIG_fail;
ecode1 = SWIG_AsVal_bool(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KCFTracker" "', argument " "1"" of type '" "bool""'");
}
arg1 = static_cast< bool >(val1);
ecode2 = SWIG_AsVal_bool(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_KCFTracker" "', argument " "2"" of type '" "bool""'");
}
arg2 = static_cast< bool >(val2);
result = (KCFTracker *)new KCFTracker(arg1,arg2);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_KCFTracker, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_KCFTracker__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
bool arg1 ;
bool val1 ;
int ecode1 = 0 ;
PyObject * obj0 = 0 ;
KCFTracker *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new_KCFTracker",&obj0)) SWIG_fail;
ecode1 = SWIG_AsVal_bool(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KCFTracker" "', argument " "1"" of type '" "bool""'");
}
arg1 = static_cast< bool >(val1);
result = (KCFTracker *)new KCFTracker(arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_KCFTracker, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_KCFTracker__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
KCFTracker *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new_KCFTracker")) SWIG_fail;
result = (KCFTracker *)new KCFTracker();
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_KCFTracker, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_KCFTracker(PyObject *self, PyObject *args) {
Py_ssize_t argc;
PyObject *argv[5] = {
0
};
Py_ssize_t ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = args ? PyObject_Length(args) : 0;
for (ii = 0; (ii < 4) && (ii < argc); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 0) {
return _wrap_new_KCFTracker__SWIG_4(self, args);
}
if (argc == 1) {
int _v;
{
int res = SWIG_AsVal_bool(argv[0], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_new_KCFTracker__SWIG_3(self, args);
}
}
if (argc == 2) {
int _v;
{
int res = SWIG_AsVal_bool(argv[0], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_bool(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_new_KCFTracker__SWIG_2(self, args);
}
}
}
if (argc == 3) {
int _v;
{
int res = SWIG_AsVal_bool(argv[0], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_bool(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_bool(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_new_KCFTracker__SWIG_1(self, args);
}
}
}
}
if (argc == 4) {
int _v;
{
int res = SWIG_AsVal_bool(argv[0], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_bool(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_bool(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_bool(argv[3], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_new_KCFTracker__SWIG_0(self, args);
}
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_KCFTracker'.\n"
" Possible C/C++ prototypes are:\n"
" KCFTracker::KCFTracker(bool,bool,bool,bool)\n"
" KCFTracker::KCFTracker(bool,bool,bool)\n"
" KCFTracker::KCFTracker(bool,bool)\n"
" KCFTracker::KCFTracker(bool)\n"
" KCFTracker::KCFTracker()\n");
return 0;
}
SWIGINTERN PyObject *_wrap_delete_KCFTracker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
KCFTracker *arg1 = (KCFTracker *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_KCFTracker",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_KCFTracker, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_KCFTracker" "', argument " "1"" of type '" "KCFTracker *""'");
}
arg1 = reinterpret_cast< KCFTracker * >(argp1);
delete arg1;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_KCFTracker_init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
KCFTracker *arg1 = (KCFTracker *) 0 ;
cv::Rect *arg2 = 0 ;
cv::Mat 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 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:KCFTracker_init",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_KCFTracker, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KCFTracker_init" "', argument " "1"" of type '" "KCFTracker *""'");
}
arg1 = reinterpret_cast< KCFTracker * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__Rect_T_int_t, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KCFTracker_init" "', argument " "2"" of type '" "cv::Rect const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KCFTracker_init" "', argument " "2"" of type '" "cv::Rect const &""'");
}
arg2 = reinterpret_cast< cv::Rect * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_cv__Mat, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "KCFTracker_init" "', argument " "3"" of type '" "cv::Mat""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KCFTracker_init" "', argument " "3"" of type '" "cv::Mat""'");
} else {
cv::Mat * temp = reinterpret_cast< cv::Mat * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
(arg1)->init((cv::Rect const &)*arg2,arg3);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_KCFTracker_update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
KCFTracker *arg1 = (KCFTracker *) 0 ;
cv::Mat arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
SwigValueWrapper< cv::Rect_< int > > result;
if (!PyArg_ParseTuple(args,(char *)"OO:KCFTracker_update",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_KCFTracker, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KCFTracker_update" "', argument " "1"" of type '" "KCFTracker *""'");
}
arg1 = reinterpret_cast< KCFTracker * >(argp1);
{
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_cv__Mat, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KCFTracker_update" "', argument " "2"" of type '" "cv::Mat""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KCFTracker_update" "', argument " "2"" of type '" "cv::Mat""'");
} else {
cv::Mat * temp = reinterpret_cast< cv::Mat * >(argp2);
arg2 = *temp;
if (SWIG_IsNewObj(res2)) delete temp;
}
}
result = (arg1)->update(arg2);
resultobj = SWIG_NewPointerObj((new cv::Rect(static_cast< const cv::Rect& >(result))), SWIGTYPE_p_cv__Rect_T_int_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_KCFTracker_interp_factor_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
KCFTracker *arg1 = (KCFTracker *) 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:KCFTracker_interp_factor_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_KCFTracker, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KCFTracker_interp_factor_set" "', argument " "1"" of type '" "KCFTracker *""'");
}
arg1 = reinterpret_cast< KCFTracker * >(argp1);
ecode2 = SWIG_AsVal_float(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KCFTracker_interp_factor_set" "', argument " "2"" of type '" "float""'");
}
arg2 = static_cast< float >(val2);
if (arg1) (arg1)->interp_factor = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_KCFTracker_interp_factor_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
KCFTracker *arg1 = (KCFTracker *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
float result;
if (!PyArg_ParseTuple(args,(char *)"O:KCFTracker_interp_factor_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_KCFTracker, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KCFTracker_interp_factor_get" "', argument " "1"" of type '" "KCFTracker *""'");
}
arg1 = reinterpret_cast< KCFTracker * >(argp1);
result = (float) ((arg1)->interp_factor);
resultobj = SWIG_From_float(static_cast< float >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_KCFTracker_sigma_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
KCFTracker *arg1 = (KCFTracker *) 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:KCFTracker_sigma_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_KCFTracker, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KCFTracker_sigma_set" "', argument " "1"" of type '" "KCFTracker *""'");
}
arg1 = reinterpret_cast< KCFTracker * >(argp1);
ecode2 = SWIG_AsVal_float(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KCFTracker_sigma_set" "', argument " "2"" of type '" "float""'");
}
arg2 = static_cast< float >(val2);
if (arg1) (arg1)->sigma = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_KCFTracker_sigma_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
KCFTracker *arg1 = (KCFTracker *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
float result;
if (!PyArg_ParseTuple(args,(char *)"O:KCFTracker_sigma_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_KCFTracker, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KCFTracker_sigma_get" "', argument " "1"" of type '" "KCFTracker *""'");
}
arg1 = reinterpret_cast< KCFTracker * >(argp1);
result = (float) ((arg1)->sigma);
resultobj = SWIG_From_float(static_cast< float >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_KCFTracker__lambda_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
KCFTracker *arg1 = (KCFTracker *) 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:KCFTracker__lambda_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_KCFTracker, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KCFTracker__lambda_set" "', argument " "1"" of type '" "KCFTracker *""'");
}
arg1 = reinterpret_cast< KCFTracker * >(argp1);
ecode2 = SWIG_AsVal_float(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KCFTracker__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_KCFTracker__lambda_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
KCFTracker *arg1 = (KCFTracker *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
float result;
if (!PyArg_ParseTuple(args,(char *)"O:KCFTracker__lambda_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_KCFTracker, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KCFTracker__lambda_get" "', argument " "1"" of type '" "KCFTracker *""'");
}
arg1 = reinterpret_cast< KCFTracker * >(argp1);
result = (float) ((arg1)->_lambda);
resultobj = SWIG_From_float(static_cast< float >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_KCFTracker_cell_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
KCFTracker *arg1 = (KCFTracker *) 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:KCFTracker_cell_size_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_KCFTracker, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KCFTracker_cell_size_set" "', argument " "1"" of type '" "KCFTracker *""'");
}
arg1 = reinterpret_cast< KCFTracker * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KCFTracker_cell_size_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->cell_size = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_KCFTracker_cell_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
KCFTracker *arg1 = (KCFTracker *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:KCFTracker_cell_size_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_KCFTracker, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KCFTracker_cell_size_get" "', argument " "1"" of type '" "KCFTracker *""'");
}
arg1 = reinterpret_cast< KCFTracker * >(argp1);
result = (int) ((arg1)->cell_size);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_KCFTracker_cell_sizeQ_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
KCFTracker *arg1 = (KCFTracker *) 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:KCFTracker_cell_sizeQ_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_KCFTracker, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KCFTracker_cell_sizeQ_set" "', argument " "1"" of type '" "KCFTracker *""'");
}
arg1 = reinterpret_cast< KCFTracker * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KCFTracker_cell_sizeQ_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->cell_sizeQ = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_KCFTracker_cell_sizeQ_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
KCFTracker *arg1 = (KCFTracker *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:KCFTracker_cell_sizeQ_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_KCFTracker, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KCFTracker_cell_sizeQ_get" "', argument " "1"" of type '" "KCFTracker *""'");
}
arg1 = reinterpret_cast< KCFTracker * >(argp1);
result = (int) ((arg1)->cell_sizeQ);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_KCFTracker_padding_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
KCFTracker *arg1 = (KCFTracker *) 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:KCFTracker_padding_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_KCFTracker, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KCFTracker_padding_set" "', argument " "1"" of type '" "KCFTracker *""'");
}
arg1 = reinterpret_cast< KCFTracker * >(argp1);
ecode2 = SWIG_AsVal_float(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KCFTracker_padding_set" "', argument " "2"" of type '" "float""'");
}
arg2 = static_cast< float >(val2);
if (arg1) (arg1)->padding = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_KCFTracker_padding_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
KCFTracker *arg1 = (KCFTracker *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
float result;
if (!PyArg_ParseTuple(args,(char *)"O:KCFTracker_padding_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_KCFTracker, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KCFTracker_padding_get" "', argument " "1"" of type '" "KCFTracker *""'");
}
arg1 = reinterpret_cast< KCFTracker * >(argp1);
result = (float) ((arg1)->padding);
resultobj = SWIG_From_float(static_cast< float >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_KCFTracker_output_sigma_factor_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
KCFTracker *arg1 = (KCFTracker *) 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:KCFTracker_output_sigma_factor_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_KCFTracker, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KCFTracker_output_sigma_factor_set" "', argument " "1"" of type '" "KCFTracker *""'");
}
arg1 = reinterpret_cast< KCFTracker * >(argp1);
ecode2 = SWIG_AsVal_float(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KCFTracker_output_sigma_factor_set" "', argument " "2"" of type '" "float""'");
}
arg2 = static_cast< float >(val2);
if (arg1) (arg1)->output_sigma_factor = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_KCFTracker_output_sigma_factor_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
KCFTracker *arg1 = (KCFTracker *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
float result;
if (!PyArg_ParseTuple(args,(char *)"O:KCFTracker_output_sigma_factor_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_KCFTracker, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KCFTracker_output_sigma_factor_get" "', argument " "1"" of type '" "KCFTracker *""'");
}
arg1 = reinterpret_cast< KCFTracker * >(argp1);
result = (float) ((arg1)->output_sigma_factor);
resultobj = SWIG_From_float(static_cast< float >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_KCFTracker_template_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
KCFTracker *arg1 = (KCFTracker *) 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:KCFTracker_template_size_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_KCFTracker, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KCFTracker_template_size_set" "', argument " "1"" of type '" "KCFTracker *""'");
}
arg1 = reinterpret_cast< KCFTracker * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KCFTracker_template_size_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->template_size = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_KCFTracker_template_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
KCFTracker *arg1 = (KCFTracker *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:KCFTracker_template_size_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_KCFTracker, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KCFTracker_template_size_get" "', argument " "1"" of type '" "KCFTracker *""'");
}
arg1 = reinterpret_cast< KCFTracker * >(argp1);
result = (int) ((arg1)->template_size);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN int Swig_var_KCFTracker_pCmDev_set(PyObject *_val) {
{
void *argp = 0;
int res = SWIG_ConvertPtr(_val, &argp, SWIGTYPE_p_CmDevice, 0 );
if (!SWIG_IsOK(res)) {
SWIG_exception_fail(SWIG_ArgError(res), "in variable '""KCFTracker::pCmDev""' of type '""CmDevice *""'");
}
KCFTracker::pCmDev = reinterpret_cast< CmDevice * >(argp);
}
return 0;
fail:
return 1;
}
SWIGINTERN PyObject *Swig_var_KCFTracker_pCmDev_get(void) {
PyObject *pyobj = 0;
pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(KCFTracker::pCmDev), SWIGTYPE_p_CmDevice, 0 );
return pyobj;
}
SWIGINTERN PyObject *_wrap_KCFTracker_pCmDev_get(PyObject *SWIGUNUSEDPARM(self), PyObject *SWIGUNUSEDPARM(args)) {
return Swig_var_KCFTracker_pCmDev_get();
}
SWIGINTERN PyObject *_wrap_KCFTracker_pCmDev_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
int res;
PyObject *value;
if (!PyArg_ParseTuple(args,(char *)"O:set",&value)) return NULL;
res = Swig_var_KCFTracker_pCmDev_set(value);
return !res ? SWIG_Py_Void() : NULL;
}
SWIGINTERN PyObject *KCFTracker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_KCFTracker, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
static PyMethodDef SwigMethods[] = {
{ (char *)"SWIG_PyInstanceMethod_New", (PyCFunction)SWIG_PyInstanceMethod_New, METH_O, NULL},
{ (char *)"CV_VERSION_MAJOR_swigconstant", CV_VERSION_MAJOR_swigconstant, METH_VARARGS, NULL},
{ (char *)"CV_VERSION_MINOR_swigconstant", CV_VERSION_MINOR_swigconstant, METH_VARARGS, NULL},
{ (char *)"CV_VERSION_REVISION_swigconstant", CV_VERSION_REVISION_swigconstant, METH_VARARGS, NULL},
{ (char *)"CV_VERSION_STATUS_swigconstant", CV_VERSION_STATUS_swigconstant, METH_VARARGS, NULL},
{ (char *)"CV_VERSION_swigconstant", CV_VERSION_swigconstant, METH_VARARGS, NULL},
{ (char *)"CV_MAJOR_VERSION_swigconstant", CV_MAJOR_VERSION_swigconstant, METH_VARARGS, NULL},
{ (char *)"CV_MINOR_VERSION_swigconstant", CV_MINOR_VERSION_swigconstant, METH_VARARGS, NULL},
{ (char *)"CV_SUBMINOR_VERSION_swigconstant", CV_SUBMINOR_VERSION_swigconstant, METH_VARARGS, NULL},
{ (char *)"new_DataType_bool", _wrap_new_DataType_bool, METH_VARARGS, NULL},
{ (char *)"delete_DataType_bool", _wrap_delete_DataType_bool, METH_VARARGS, NULL},
{ (char *)"DataType_bool_swigregister", DataType_bool_swigregister, METH_VARARGS, NULL},
{ (char *)"new_DataType_uchar", _wrap_new_DataType_uchar, METH_VARARGS, NULL},
{ (char *)"delete_DataType_uchar", _wrap_delete_DataType_uchar, METH_VARARGS, NULL},
{ (char *)"DataType_uchar_swigregister", DataType_uchar_swigregister, METH_VARARGS, NULL},
{ (char *)"new_DataType_schar", _wrap_new_DataType_schar, METH_VARARGS, NULL},
{ (char *)"delete_DataType_schar", _wrap_delete_DataType_schar, METH_VARARGS, NULL},
{ (char *)"DataType_schar_swigregister", DataType_schar_swigregister, METH_VARARGS, NULL},
{ (char *)"new_DataType_char", _wrap_new_DataType_char, METH_VARARGS, NULL},
{ (char *)"delete_DataType_char", _wrap_delete_DataType_char, METH_VARARGS, NULL},
{ (char *)"DataType_char_swigregister", DataType_char_swigregister, METH_VARARGS, NULL},
{ (char *)"new_DataType_ushort", _wrap_new_DataType_ushort, METH_VARARGS, NULL},
{ (char *)"delete_DataType_ushort", _wrap_delete_DataType_ushort, METH_VARARGS, NULL},
{ (char *)"DataType_ushort_swigregister", DataType_ushort_swigregister, METH_VARARGS, NULL},
{ (char *)"new_DataType_short", _wrap_new_DataType_short, METH_VARARGS, NULL},
{ (char *)"delete_DataType_short", _wrap_delete_DataType_short, METH_VARARGS, NULL},
{ (char *)"DataType_short_swigregister", DataType_short_swigregister, METH_VARARGS, NULL},
{ (char *)"new_DataType_int", _wrap_new_DataType_int, METH_VARARGS, NULL},
{ (char *)"delete_DataType_int", _wrap_delete_DataType_int, METH_VARARGS, NULL},
{ (char *)"DataType_int_swigregister", DataType_int_swigregister, METH_VARARGS, NULL},
{ (char *)"new_DataType_float", _wrap_new_DataType_float, METH_VARARGS, NULL},
{ (char *)"delete_DataType_float", _wrap_delete_DataType_float, METH_VARARGS, NULL},
{ (char *)"DataType_float_swigregister", DataType_float_swigregister, METH_VARARGS, NULL},
{ (char *)"new_DataType_double", _wrap_new_DataType_double, METH_VARARGS, NULL},
{ (char *)"delete_DataType_double", _wrap_delete_DataType_double, METH_VARARGS, NULL},
{ (char *)"DataType_double_swigregister", DataType_double_swigregister, METH_VARARGS, NULL},
{ (char *)"new_Range", _wrap_new_Range, METH_VARARGS, NULL},
{ (char *)"Range_size", _wrap_Range_size, METH_VARARGS, NULL},
{ (char *)"Range_empty", _wrap_Range_empty, METH_VARARGS, NULL},
{ (char *)"Range_all", _wrap_Range_all, METH_VARARGS, NULL},
{ (char *)"Range_start_set", _wrap_Range_start_set, METH_VARARGS, NULL},
{ (char *)"Range_start_get", _wrap_Range_start_get, METH_VARARGS, NULL},
{ (char *)"Range_end_set", _wrap_Range_end_set, METH_VARARGS, NULL},
{ (char *)"Range_end_get", _wrap_Range_end_get, METH_VARARGS, NULL},
{ (char *)"delete_Range", _wrap_delete_Range, METH_VARARGS, NULL},
{ (char *)"Range_swigregister", Range_swigregister, METH_VARARGS, NULL},
{ (char *)"delete_SwigPyIterator", _wrap_delete_SwigPyIterator, METH_VARARGS, NULL},
{ (char *)"SwigPyIterator_value", _wrap_SwigPyIterator_value, METH_VARARGS, NULL},
{ (char *)"SwigPyIterator_incr", _wrap_SwigPyIterator_incr, METH_VARARGS, NULL},
{ (char *)"SwigPyIterator_decr", _wrap_SwigPyIterator_decr, METH_VARARGS, NULL},
{ (char *)"SwigPyIterator_distance", _wrap_SwigPyIterator_distance, METH_VARARGS, NULL},
{ (char *)"SwigPyIterator_equal", _wrap_SwigPyIterator_equal, METH_VARARGS, NULL},
{ (char *)"SwigPyIterator_copy", _wrap_SwigPyIterator_copy, METH_VARARGS, NULL},
{ (char *)"SwigPyIterator_next", _wrap_SwigPyIterator_next, METH_VARARGS, NULL},
{ (char *)"SwigPyIterator___next__", _wrap_SwigPyIterator___next__, METH_VARARGS, NULL},
{ (char *)"SwigPyIterator_previous", _wrap_SwigPyIterator_previous, METH_VARARGS, NULL},
{ (char *)"SwigPyIterator_advance", _wrap_SwigPyIterator_advance, METH_VARARGS, NULL},
{ (char *)"SwigPyIterator___eq__", _wrap_SwigPyIterator___eq__, METH_VARARGS, NULL},
{ (char *)"SwigPyIterator___ne__", _wrap_SwigPyIterator___ne__, METH_VARARGS, NULL},
{ (char *)"SwigPyIterator___iadd__", _wrap_SwigPyIterator___iadd__, METH_VARARGS, NULL},
{ (char *)"SwigPyIterator___isub__", _wrap_SwigPyIterator___isub__, METH_VARARGS, NULL},
{ (char *)"SwigPyIterator___add__", _wrap_SwigPyIterator___add__, METH_VARARGS, NULL},
{ (char *)"SwigPyIterator___sub__", _wrap_SwigPyIterator___sub__, METH_VARARGS, NULL},
{ (char *)"SwigPyIterator_swigregister", SwigPyIterator_swigregister, METH_VARARGS, NULL},
{ (char *)"new_Matx_AddOp", _wrap_new_Matx_AddOp, METH_VARARGS, NULL},
{ (char *)"delete_Matx_AddOp", _wrap_delete_Matx_AddOp, METH_VARARGS, NULL},
{ (char *)"Matx_AddOp_swigregister", Matx_AddOp_swigregister, METH_VARARGS, NULL},
{ (char *)"new_Matx_SubOp", _wrap_new_Matx_SubOp, METH_VARARGS, NULL},
{ (char *)"delete_Matx_SubOp", _wrap_delete_Matx_SubOp, METH_VARARGS, NULL},
{ (char *)"Matx_SubOp_swigregister", Matx_SubOp_swigregister, METH_VARARGS, NULL},
{ (char *)"new_Matx_ScaleOp", _wrap_new_Matx_ScaleOp, METH_VARARGS, NULL},
{ (char *)"delete_Matx_ScaleOp", _wrap_delete_Matx_ScaleOp, METH_VARARGS, NULL},
{ (char *)"Matx_ScaleOp_swigregister", Matx_ScaleOp_swigregister, METH_VARARGS, NULL},
{ (char *)"new_Matx_MulOp", _wrap_new_Matx_MulOp, METH_VARARGS, NULL},
{ (char *)"delete_Matx_MulOp", _wrap_delete_Matx_MulOp, METH_VARARGS, NULL},
{ (char *)"Matx_MulOp_swigregister", Matx_MulOp_swigregister, METH_VARARGS, NULL},
{ (char *)"new_Matx_DivOp", _wrap_new_Matx_DivOp, METH_VARARGS, NULL},
{ (char *)"delete_Matx_DivOp", _wrap_delete_Matx_DivOp, METH_VARARGS, NULL},
{ (char *)"Matx_DivOp_swigregister", Matx_DivOp_swigregister, METH_VARARGS, NULL},
{ (char *)"new_Matx_MatMulOp", _wrap_new_Matx_MatMulOp, METH_VARARGS, NULL},
{ (char *)"delete_Matx_MatMulOp", _wrap_delete_Matx_MatMulOp, METH_VARARGS, NULL},
{ (char *)"Matx_MatMulOp_swigregister", Matx_MatMulOp_swigregister, METH_VARARGS, NULL},
{ (char *)"new_Matx_TOp", _wrap_new_Matx_TOp, METH_VARARGS, NULL},
{ (char *)"delete_Matx_TOp", _wrap_delete_Matx_TOp, METH_VARARGS, NULL},
{ (char *)"Matx_TOp_swigregister", Matx_TOp_swigregister, METH_VARARGS, NULL},
{ (char *)"delete_Mat", _wrap_delete_Mat, METH_VARARGS, NULL},
{ (char *)"Mat_row", _wrap_Mat_row, METH_VARARGS, NULL},
{ (char *)"Mat_col", _wrap_Mat_col, METH_VARARGS, NULL},
{ (char *)"Mat_rowRange", _wrap_Mat_rowRange, METH_VARARGS, NULL},
{ (char *)"Mat_colRange", _wrap_Mat_colRange, METH_VARARGS, NULL},
{ (char *)"Mat_diag", _wrap_Mat_diag, METH_VARARGS, NULL},
{ (char *)"Mat_clone", _wrap_Mat_clone, METH_VARARGS, NULL},
{ (char *)"Mat_assignTo", _wrap_Mat_assignTo, METH_VARARGS, NULL},
{ (char *)"Mat_reshape", _wrap_Mat_reshape, METH_VARARGS, NULL},
{ (char *)"Mat_create", _wrap_Mat_create, METH_VARARGS, NULL},
{ (char *)"Mat_addref", _wrap_Mat_addref, METH_VARARGS, NULL},
{ (char *)"Mat_release", _wrap_Mat_release, METH_VARARGS, NULL},
{ (char *)"Mat_deallocate", _wrap_Mat_deallocate, METH_VARARGS, NULL},
{ (char *)"Mat_copySize", _wrap_Mat_copySize, METH_VARARGS, NULL},
{ (char *)"Mat_reserve", _wrap_Mat_reserve, METH_VARARGS, NULL},
{ (char *)"Mat_resize", _wrap_Mat_resize, METH_VARARGS, NULL},
{ (char *)"Mat_push_back_", _wrap_Mat_push_back_, METH_VARARGS, NULL},
{ (char *)"Mat_push_back", _wrap_Mat_push_back, METH_VARARGS, NULL},
{ (char *)"Mat_pop_back", _wrap_Mat_pop_back, METH_VARARGS, NULL},
{ (char *)"Mat_locateROI", _wrap_Mat_locateROI, METH_VARARGS, NULL},
{ (char *)"Mat_adjustROI", _wrap_Mat_adjustROI, METH_VARARGS, NULL},
{ (char *)"Mat___call__", _wrap_Mat___call__, METH_VARARGS, NULL},
{ (char *)"Mat_isContinuous", _wrap_Mat_isContinuous, METH_VARARGS, NULL},
{ (char *)"Mat_isSubmatrix", _wrap_Mat_isSubmatrix, METH_VARARGS, NULL},
{ (char *)"Mat_elemSize", _wrap_Mat_elemSize, METH_VARARGS, NULL},
{ (char *)"Mat_elemSize1", _wrap_Mat_elemSize1, METH_VARARGS, NULL},
{ (char *)"Mat_type", _wrap_Mat_type, METH_VARARGS, NULL},
{ (char *)"Mat_depth", _wrap_Mat_depth, METH_VARARGS, NULL},
{ (char *)"Mat_channels", _wrap_Mat_channels, METH_VARARGS, NULL},
{ (char *)"Mat_step1", _wrap_Mat_step1, METH_VARARGS, NULL},
{ (char *)"Mat_empty", _wrap_Mat_empty, METH_VARARGS, NULL},
{ (char *)"Mat_total", _wrap_Mat_total, METH_VARARGS, NULL},
{ (char *)"Mat_checkVector", _wrap_Mat_checkVector, METH_VARARGS, NULL},
{ (char *)"Mat_ptr", _wrap_Mat_ptr, METH_VARARGS, NULL},
{ (char *)"Mat_flags_set", _wrap_Mat_flags_set, METH_VARARGS, NULL},
{ (char *)"Mat_flags_get", _wrap_Mat_flags_get, METH_VARARGS, NULL},
{ (char *)"Mat_dims_set", _wrap_Mat_dims_set, METH_VARARGS, NULL},
{ (char *)"Mat_dims_get", _wrap_Mat_dims_get, METH_VARARGS, NULL},
{ (char *)"Mat_rows_set", _wrap_Mat_rows_set, METH_VARARGS, NULL},
{ (char *)"Mat_rows_get", _wrap_Mat_rows_get, METH_VARARGS, NULL},
{ (char *)"Mat_cols_set", _wrap_Mat_cols_set, METH_VARARGS, NULL},
{ (char *)"Mat_cols_get", _wrap_Mat_cols_get, METH_VARARGS, NULL},
{ (char *)"Mat_data_set", _wrap_Mat_data_set, METH_VARARGS, NULL},
{ (char *)"Mat_data_get", _wrap_Mat_data_get, METH_VARARGS, NULL},
{ (char *)"Mat_datastart_set", _wrap_Mat_datastart_set, METH_VARARGS, NULL},
{ (char *)"Mat_datastart_get", _wrap_Mat_datastart_get, METH_VARARGS, NULL},
{ (char *)"Mat_dataend_set", _wrap_Mat_dataend_set, METH_VARARGS, NULL},
{ (char *)"Mat_dataend_get", _wrap_Mat_dataend_get, METH_VARARGS, NULL},
{ (char *)"Mat_datalimit_set", _wrap_Mat_datalimit_set, METH_VARARGS, NULL},
{ (char *)"Mat_datalimit_get", _wrap_Mat_datalimit_get, METH_VARARGS, NULL},
{ (char *)"new_Mat", _wrap_new_Mat, METH_VARARGS, NULL},
{ (char *)"Mat___str__", _wrap_Mat___str__, METH_VARARGS, NULL},
{ (char *)"Mat_swigregister", Mat_swigregister, METH_VARARGS, NULL},
{ (char *)"new__cv_numpy_sizeof_uint8_t", _wrap_new__cv_numpy_sizeof_uint8_t, METH_VARARGS, NULL},
{ (char *)"delete__cv_numpy_sizeof_uint8_t", _wrap_delete__cv_numpy_sizeof_uint8_t, METH_VARARGS, NULL},
{ (char *)"_cv_numpy_sizeof_uint8_t_swigregister", _cv_numpy_sizeof_uint8_t_swigregister, METH_VARARGS, NULL},
{ (char *)"_uint8_tArray_iterator", _wrap__uint8_tArray_iterator, METH_VARARGS, NULL},
{ (char *)"_uint8_tArray___nonzero__", _wrap__uint8_tArray___nonzero__, METH_VARARGS, NULL},
{ (char *)"_uint8_tArray___bool__", _wrap__uint8_tArray___bool__, METH_VARARGS, NULL},
{ (char *)"_uint8_tArray___len__", _wrap__uint8_tArray___len__, METH_VARARGS, NULL},
{ (char *)"_uint8_tArray___getslice__", _wrap__uint8_tArray___getslice__, METH_VARARGS, NULL},
{ (char *)"_uint8_tArray___setslice__", _wrap__uint8_tArray___setslice__, METH_VARARGS, NULL},
{ (char *)"_uint8_tArray___delslice__", _wrap__uint8_tArray___delslice__, METH_VARARGS, NULL},
{ (char *)"_uint8_tArray___delitem__", _wrap__uint8_tArray___delitem__, METH_VARARGS, NULL},
{ (char *)"_uint8_tArray___getitem__", _wrap__uint8_tArray___getitem__, METH_VARARGS, NULL},
{ (char *)"_uint8_tArray___setitem__", _wrap__uint8_tArray___setitem__, METH_VARARGS, NULL},
{ (char *)"_uint8_tArray_pop", _wrap__uint8_tArray_pop, METH_VARARGS, NULL},
{ (char *)"_uint8_tArray_append", _wrap__uint8_tArray_append, METH_VARARGS, NULL},
{ (char *)"_uint8_tArray_empty", _wrap__uint8_tArray_empty, METH_VARARGS, NULL},
{ (char *)"_uint8_tArray_size", _wrap__uint8_tArray_size, METH_VARARGS, NULL},
{ (char *)"_uint8_tArray_swap", _wrap__uint8_tArray_swap, METH_VARARGS, NULL},
{ (char *)"_uint8_tArray_begin", _wrap__uint8_tArray_begin, METH_VARARGS, NULL},
{ (char *)"_uint8_tArray_end", _wrap__uint8_tArray_end, METH_VARARGS, NULL},
{ (char *)"_uint8_tArray_rbegin", _wrap__uint8_tArray_rbegin, METH_VARARGS, NULL},
{ (char *)"_uint8_tArray_rend", _wrap__uint8_tArray_rend, METH_VARARGS, NULL},
{ (char *)"_uint8_tArray_clear", _wrap__uint8_tArray_clear, METH_VARARGS, NULL},
{ (char *)"_uint8_tArray_get_allocator", _wrap__uint8_tArray_get_allocator, METH_VARARGS, NULL},
{ (char *)"_uint8_tArray_pop_back", _wrap__uint8_tArray_pop_back, METH_VARARGS, NULL},
{ (char *)"_uint8_tArray_erase", _wrap__uint8_tArray_erase, METH_VARARGS, NULL},
{ (char *)"new__uint8_tArray", _wrap_new__uint8_tArray, METH_VARARGS, NULL},
{ (char *)"_uint8_tArray_push_back", _wrap__uint8_tArray_push_back, METH_VARARGS, NULL},
{ (char *)"_uint8_tArray_front", _wrap__uint8_tArray_front, METH_VARARGS, NULL},
{ (char *)"_uint8_tArray_back", _wrap__uint8_tArray_back, METH_VARARGS, NULL},
{ (char *)"_uint8_tArray_assign", _wrap__uint8_tArray_assign, METH_VARARGS, NULL},
{ (char *)"_uint8_tArray_resize", _wrap__uint8_tArray_resize, METH_VARARGS, NULL},
{ (char *)"_uint8_tArray_insert", _wrap__uint8_tArray_insert, METH_VARARGS, NULL},
{ (char *)"_uint8_tArray_reserve", _wrap__uint8_tArray_reserve, METH_VARARGS, NULL},
{ (char *)"_uint8_tArray_capacity", _wrap__uint8_tArray_capacity, METH_VARARGS, NULL},
{ (char *)"delete__uint8_tArray", _wrap_delete__uint8_tArray, METH_VARARGS, NULL},
{ (char *)"_uint8_tArray_swigregister", _uint8_tArray_swigregister, METH_VARARGS, NULL},
{ (char *)"_Matx_uint8_t_2_1_all", _wrap__Matx_uint8_t_2_1_all, METH_VARARGS, NULL},
{ (char *)"_Matx_uint8_t_2_1_zeros", _wrap__Matx_uint8_t_2_1_zeros, METH_VARARGS, NULL},
{ (char *)"_Matx_uint8_t_2_1_ones", _wrap__Matx_uint8_t_2_1_ones, METH_VARARGS, NULL},
{ (char *)"_Matx_uint8_t_2_1_eye", _wrap__Matx_uint8_t_2_1_eye, METH_VARARGS, NULL},
{ (char *)"_Matx_uint8_t_2_1_randu", _wrap__Matx_uint8_t_2_1_randu, METH_VARARGS, NULL},
{ (char *)"_Matx_uint8_t_2_1_randn", _wrap__Matx_uint8_t_2_1_randn, METH_VARARGS, NULL},
{ (char *)"_Matx_uint8_t_2_1_dot", _wrap__Matx_uint8_t_2_1_dot, METH_VARARGS, NULL},
{ (char *)"_Matx_uint8_t_2_1_ddot", _wrap__Matx_uint8_t_2_1_ddot, METH_VARARGS, NULL},
{ (char *)"_Matx_uint8_t_2_1_t", _wrap__Matx_uint8_t_2_1_t, METH_VARARGS, NULL},
{ (char *)"_Matx_uint8_t_2_1_mul", _wrap__Matx_uint8_t_2_1_mul, METH_VARARGS, NULL},
{ (char *)"_Matx_uint8_t_2_1_div", _wrap__Matx_uint8_t_2_1_div, METH_VARARGS, NULL},
{ (char *)"_Matx_uint8_t_2_1___call__", _wrap__Matx_uint8_t_2_1___call__, METH_VARARGS, NULL},
{ (char *)"_Matx_uint8_t_2_1_val_set", _wrap__Matx_uint8_t_2_1_val_set, METH_VARARGS, NULL},
{ (char *)"_Matx_uint8_t_2_1_val_get", _wrap__Matx_uint8_t_2_1_val_get, METH_VARARGS, NULL},
{ (char *)"new__Matx_uint8_t_2_1", _wrap_new__Matx_uint8_t_2_1, METH_VARARGS, NULL},
{ (char *)"_Matx_uint8_t_2_1___str__", _wrap__Matx_uint8_t_2_1___str__, METH_VARARGS, NULL},
{ (char *)"delete__Matx_uint8_t_2_1", _wrap_delete__Matx_uint8_t_2_1, METH_VARARGS, NULL},
{ (char *)"_Matx_uint8_t_2_1_swigregister", _Matx_uint8_t_2_1_swigregister, METH_VARARGS, NULL},
{ (char *)"_Vec_uint8_t_2_all", _wrap__Vec_uint8_t_2_all, METH_VARARGS, NULL},
{ (char *)"_Vec_uint8_t_2_mul", _wrap__Vec_uint8_t_2_mul, METH_VARARGS, NULL},
{ (char *)"_Vec_uint8_t_2___call__", _wrap__Vec_uint8_t_2___call__, METH_VARARGS, NULL},
{ (char *)"new__Vec_uint8_t_2", _wrap_new__Vec_uint8_t_2, METH_VARARGS, NULL},
{ (char *)"_Vec_uint8_t_2___str__", _wrap__Vec_uint8_t_2___str__, METH_VARARGS, NULL},
{ (char *)"delete__Vec_uint8_t_2", _wrap_delete__Vec_uint8_t_2, METH_VARARGS, NULL},
{ (char *)"_Vec_uint8_t_2_swigregister", _Vec_uint8_t_2_swigregister, METH_VARARGS, NULL},
{ (char *)"new__DataType_Vec_uint8_t_2", _wrap_new__DataType_Vec_uint8_t_2, METH_VARARGS, NULL},
{ (char *)"delete__DataType_Vec_uint8_t_2", _wrap_delete__DataType_Vec_uint8_t_2, METH_VARARGS, NULL},
{ (char *)"_DataType_Vec_uint8_t_2_swigregister", _DataType_Vec_uint8_t_2_swigregister, METH_VARARGS, NULL},
{ (char *)"_Matx_uint8_t_3_1_all", _wrap__Matx_uint8_t_3_1_all, METH_VARARGS, NULL},
{ (char *)"_Matx_uint8_t_3_1_zeros", _wrap__Matx_uint8_t_3_1_zeros, METH_VARARGS, NULL},
{ (char *)"_Matx_uint8_t_3_1_ones", _wrap__Matx_uint8_t_3_1_ones, METH_VARARGS, NULL},
{ (char *)"_Matx_uint8_t_3_1_eye", _wrap__Matx_uint8_t_3_1_eye, METH_VARARGS, NULL},
{ (char *)"_Matx_uint8_t_3_1_randu", _wrap__Matx_uint8_t_3_1_randu, METH_VARARGS, NULL},
{ (char *)"_Matx_uint8_t_3_1_randn", _wrap__Matx_uint8_t_3_1_randn, METH_VARARGS, NULL},
{ (char *)"_Matx_uint8_t_3_1_dot", _wrap__Matx_uint8_t_3_1_dot, METH_VARARGS, NULL},
{ (char *)"_Matx_uint8_t_3_1_ddot", _wrap__Matx_uint8_t_3_1_ddot, METH_VARARGS, NULL},
{ (char *)"_Matx_uint8_t_3_1_t", _wrap__Matx_uint8_t_3_1_t, METH_VARARGS, NULL},
{ (char *)"_Matx_uint8_t_3_1_mul", _wrap__Matx_uint8_t_3_1_mul, METH_VARARGS, NULL},
{ (char *)"_Matx_uint8_t_3_1_div", _wrap__Matx_uint8_t_3_1_div, METH_VARARGS, NULL},
{ (char *)"_Matx_uint8_t_3_1___call__", _wrap__Matx_uint8_t_3_1___call__, METH_VARARGS, NULL},
{ (char *)"_Matx_uint8_t_3_1_val_set", _wrap__Matx_uint8_t_3_1_val_set, METH_VARARGS, NULL},
{ (char *)"_Matx_uint8_t_3_1_val_get", _wrap__Matx_uint8_t_3_1_val_get, METH_VARARGS, NULL},
{ (char *)"new__Matx_uint8_t_3_1", _wrap_new__Matx_uint8_t_3_1, METH_VARARGS, NULL},
{ (char *)"_Matx_uint8_t_3_1___str__", _wrap__Matx_uint8_t_3_1___str__, METH_VARARGS, NULL},
{ (char *)"delete__Matx_uint8_t_3_1", _wrap_delete__Matx_uint8_t_3_1, METH_VARARGS, NULL},
{ (char *)"_Matx_uint8_t_3_1_swigregister", _Matx_uint8_t_3_1_swigregister, METH_VARARGS, NULL},
{ (char *)"_Vec_uint8_t_3_all", _wrap__Vec_uint8_t_3_all, METH_VARARGS, NULL},
{ (char *)"_Vec_uint8_t_3_mul", _wrap__Vec_uint8_t_3_mul, METH_VARARGS, NULL},
{ (char *)"_Vec_uint8_t_3___call__", _wrap__Vec_uint8_t_3___call__, METH_VARARGS, NULL},
{ (char *)"new__Vec_uint8_t_3", _wrap_new__Vec_uint8_t_3, METH_VARARGS, NULL},
{ (char *)"_Vec_uint8_t_3___str__", _wrap__Vec_uint8_t_3___str__, METH_VARARGS, NULL},
{ (char *)"delete__Vec_uint8_t_3", _wrap_delete__Vec_uint8_t_3, METH_VARARGS, NULL},
{ (char *)"_Vec_uint8_t_3_swigregister", _Vec_uint8_t_3_swigregister, METH_VARARGS, NULL},
{ (char *)"new__DataType_Vec_uint8_t_3", _wrap_new__DataType_Vec_uint8_t_3, METH_VARARGS, NULL},
{ (char *)"delete__DataType_Vec_uint8_t_3", _wrap_delete__DataType_Vec_uint8_t_3, METH_VARARGS, NULL},
{ (char *)"_DataType_Vec_uint8_t_3_swigregister", _DataType_Vec_uint8_t_3_swigregister, METH_VARARGS, NULL},
{ (char *)"_Matx_uint8_t_4_1_all", _wrap__Matx_uint8_t_4_1_all, METH_VARARGS, NULL},
{ (char *)"_Matx_uint8_t_4_1_zeros", _wrap__Matx_uint8_t_4_1_zeros, METH_VARARGS, NULL},
{ (char *)"_Matx_uint8_t_4_1_ones", _wrap__Matx_uint8_t_4_1_ones, METH_VARARGS, NULL},
{ (char *)"_Matx_uint8_t_4_1_eye", _wrap__Matx_uint8_t_4_1_eye, METH_VARARGS, NULL},
{ (char *)"_Matx_uint8_t_4_1_randu", _wrap__Matx_uint8_t_4_1_randu, METH_VARARGS, NULL},
{ (char *)"_Matx_uint8_t_4_1_randn", _wrap__Matx_uint8_t_4_1_randn, METH_VARARGS, NULL},
{ (char *)"_Matx_uint8_t_4_1_dot", _wrap__Matx_uint8_t_4_1_dot, METH_VARARGS, NULL},
{ (char *)"_Matx_uint8_t_4_1_ddot", _wrap__Matx_uint8_t_4_1_ddot, METH_VARARGS, NULL},
{ (char *)"_Matx_uint8_t_4_1_t", _wrap__Matx_uint8_t_4_1_t, METH_VARARGS, NULL},
{ (char *)"_Matx_uint8_t_4_1_mul", _wrap__Matx_uint8_t_4_1_mul, METH_VARARGS, NULL},
{ (char *)"_Matx_uint8_t_4_1_div", _wrap__Matx_uint8_t_4_1_div, METH_VARARGS, NULL},
{ (char *)"_Matx_uint8_t_4_1___call__", _wrap__Matx_uint8_t_4_1___call__, METH_VARARGS, NULL},
{ (char *)"_Matx_uint8_t_4_1_val_set", _wrap__Matx_uint8_t_4_1_val_set, METH_VARARGS, NULL},
{ (char *)"_Matx_uint8_t_4_1_val_get", _wrap__Matx_uint8_t_4_1_val_get, METH_VARARGS, NULL},
{ (char *)"new__Matx_uint8_t_4_1", _wrap_new__Matx_uint8_t_4_1, METH_VARARGS, NULL},
{ (char *)"_Matx_uint8_t_4_1___str__", _wrap__Matx_uint8_t_4_1___str__, METH_VARARGS, NULL},
{ (char *)"delete__Matx_uint8_t_4_1", _wrap_delete__Matx_uint8_t_4_1, METH_VARARGS, NULL},
{ (char *)"_Matx_uint8_t_4_1_swigregister", _Matx_uint8_t_4_1_swigregister, METH_VARARGS, NULL},
{ (char *)"_Vec_uint8_t_4_all", _wrap__Vec_uint8_t_4_all, METH_VARARGS, NULL},
{ (char *)"_Vec_uint8_t_4_mul", _wrap__Vec_uint8_t_4_mul, METH_VARARGS, NULL},
{ (char *)"_Vec_uint8_t_4___call__", _wrap__Vec_uint8_t_4___call__, METH_VARARGS, NULL},
{ (char *)"new__Vec_uint8_t_4", _wrap_new__Vec_uint8_t_4, METH_VARARGS, NULL},
{ (char *)"_Vec_uint8_t_4___str__", _wrap__Vec_uint8_t_4___str__, METH_VARARGS, NULL},
{ (char *)"delete__Vec_uint8_t_4", _wrap_delete__Vec_uint8_t_4, METH_VARARGS, NULL},
{ (char *)"_Vec_uint8_t_4_swigregister", _Vec_uint8_t_4_swigregister, METH_VARARGS, NULL},
{ (char *)"new__DataType_Vec_uint8_t_4", _wrap_new__DataType_Vec_uint8_t_4, METH_VARARGS, NULL},
{ (char *)"delete__DataType_Vec_uint8_t_4", _wrap_delete__DataType_Vec_uint8_t_4, METH_VARARGS, NULL},
{ (char *)"_DataType_Vec_uint8_t_4_swigregister", _DataType_Vec_uint8_t_4_swigregister, METH_VARARGS, NULL},
{ (char *)"new__cv_numpy_sizeof_short", _wrap_new__cv_numpy_sizeof_short, METH_VARARGS, NULL},
{ (char *)"delete__cv_numpy_sizeof_short", _wrap_delete__cv_numpy_sizeof_short, METH_VARARGS, NULL},
{ (char *)"_cv_numpy_sizeof_short_swigregister", _cv_numpy_sizeof_short_swigregister, METH_VARARGS, NULL},
{ (char *)"_shortArray_iterator", _wrap__shortArray_iterator, METH_VARARGS, NULL},
{ (char *)"_shortArray___nonzero__", _wrap__shortArray___nonzero__, METH_VARARGS, NULL},
{ (char *)"_shortArray___bool__", _wrap__shortArray___bool__, METH_VARARGS, NULL},
{ (char *)"_shortArray___len__", _wrap__shortArray___len__, METH_VARARGS, NULL},
{ (char *)"_shortArray___getslice__", _wrap__shortArray___getslice__, METH_VARARGS, NULL},
{ (char *)"_shortArray___setslice__", _wrap__shortArray___setslice__, METH_VARARGS, NULL},
{ (char *)"_shortArray___delslice__", _wrap__shortArray___delslice__, METH_VARARGS, NULL},
{ (char *)"_shortArray___delitem__", _wrap__shortArray___delitem__, METH_VARARGS, NULL},
{ (char *)"_shortArray___getitem__", _wrap__shortArray___getitem__, METH_VARARGS, NULL},
{ (char *)"_shortArray___setitem__", _wrap__shortArray___setitem__, METH_VARARGS, NULL},
{ (char *)"_shortArray_pop", _wrap__shortArray_pop, METH_VARARGS, NULL},
{ (char *)"_shortArray_append", _wrap__shortArray_append, METH_VARARGS, NULL},
{ (char *)"_shortArray_empty", _wrap__shortArray_empty, METH_VARARGS, NULL},
{ (char *)"_shortArray_size", _wrap__shortArray_size, METH_VARARGS, NULL},
{ (char *)"_shortArray_swap", _wrap__shortArray_swap, METH_VARARGS, NULL},
{ (char *)"_shortArray_begin", _wrap__shortArray_begin, METH_VARARGS, NULL},
{ (char *)"_shortArray_end", _wrap__shortArray_end, METH_VARARGS, NULL},
{ (char *)"_shortArray_rbegin", _wrap__shortArray_rbegin, METH_VARARGS, NULL},
{ (char *)"_shortArray_rend", _wrap__shortArray_rend, METH_VARARGS, NULL},
{ (char *)"_shortArray_clear", _wrap__shortArray_clear, METH_VARARGS, NULL},
{ (char *)"_shortArray_get_allocator", _wrap__shortArray_get_allocator, METH_VARARGS, NULL},
{ (char *)"_shortArray_pop_back", _wrap__shortArray_pop_back, METH_VARARGS, NULL},
{ (char *)"_shortArray_erase", _wrap__shortArray_erase, METH_VARARGS, NULL},
{ (char *)"new__shortArray", _wrap_new__shortArray, METH_VARARGS, NULL},
{ (char *)"_shortArray_push_back", _wrap__shortArray_push_back, METH_VARARGS, NULL},
{ (char *)"_shortArray_front", _wrap__shortArray_front, METH_VARARGS, NULL},
{ (char *)"_shortArray_back", _wrap__shortArray_back, METH_VARARGS, NULL},
{ (char *)"_shortArray_assign", _wrap__shortArray_assign, METH_VARARGS, NULL},
{ (char *)"_shortArray_resize", _wrap__shortArray_resize, METH_VARARGS, NULL},
{ (char *)"_shortArray_insert", _wrap__shortArray_insert, METH_VARARGS, NULL},
{ (char *)"_shortArray_reserve", _wrap__shortArray_reserve, METH_VARARGS, NULL},
{ (char *)"_shortArray_capacity", _wrap__shortArray_capacity, METH_VARARGS, NULL},
{ (char *)"delete__shortArray", _wrap_delete__shortArray, METH_VARARGS, NULL},
{ (char *)"_shortArray_swigregister", _shortArray_swigregister, METH_VARARGS, NULL},
{ (char *)"_Matx_short_2_1_all", _wrap__Matx_short_2_1_all, METH_VARARGS, NULL},
{ (char *)"_Matx_short_2_1_zeros", _wrap__Matx_short_2_1_zeros, METH_VARARGS, NULL},
{ (char *)"_Matx_short_2_1_ones", _wrap__Matx_short_2_1_ones, METH_VARARGS, NULL},
{ (char *)"_Matx_short_2_1_eye", _wrap__Matx_short_2_1_eye, METH_VARARGS, NULL},
{ (char *)"_Matx_short_2_1_randu", _wrap__Matx_short_2_1_randu, METH_VARARGS, NULL},
{ (char *)"_Matx_short_2_1_randn", _wrap__Matx_short_2_1_randn, METH_VARARGS, NULL},
{ (char *)"_Matx_short_2_1_dot", _wrap__Matx_short_2_1_dot, METH_VARARGS, NULL},
{ (char *)"_Matx_short_2_1_ddot", _wrap__Matx_short_2_1_ddot, METH_VARARGS, NULL},
{ (char *)"_Matx_short_2_1_t", _wrap__Matx_short_2_1_t, METH_VARARGS, NULL},
{ (char *)"_Matx_short_2_1_mul", _wrap__Matx_short_2_1_mul, METH_VARARGS, NULL},
{ (char *)"_Matx_short_2_1_div", _wrap__Matx_short_2_1_div, METH_VARARGS, NULL},
{ (char *)"_Matx_short_2_1___call__", _wrap__Matx_short_2_1___call__, METH_VARARGS, NULL},
{ (char *)"_Matx_short_2_1_val_set", _wrap__Matx_short_2_1_val_set, METH_VARARGS, NULL},
{ (char *)"_Matx_short_2_1_val_get", _wrap__Matx_short_2_1_val_get, METH_VARARGS, NULL},
{ (char *)"new__Matx_short_2_1", _wrap_new__Matx_short_2_1, METH_VARARGS, NULL},
{ (char *)"_Matx_short_2_1___str__", _wrap__Matx_short_2_1___str__, METH_VARARGS, NULL},
{ (char *)"delete__Matx_short_2_1", _wrap_delete__Matx_short_2_1, METH_VARARGS, NULL},
{ (char *)"_Matx_short_2_1_swigregister", _Matx_short_2_1_swigregister, METH_VARARGS, NULL},
{ (char *)"_Vec_short_2_all", _wrap__Vec_short_2_all, METH_VARARGS, NULL},
{ (char *)"_Vec_short_2_mul", _wrap__Vec_short_2_mul, METH_VARARGS, NULL},
{ (char *)"_Vec_short_2___call__", _wrap__Vec_short_2___call__, METH_VARARGS, NULL},
{ (char *)"new__Vec_short_2", _wrap_new__Vec_short_2, METH_VARARGS, NULL},
{ (char *)"_Vec_short_2___str__", _wrap__Vec_short_2___str__, METH_VARARGS, NULL},
{ (char *)"delete__Vec_short_2", _wrap_delete__Vec_short_2, METH_VARARGS, NULL},
{ (char *)"_Vec_short_2_swigregister", _Vec_short_2_swigregister, METH_VARARGS, NULL},
{ (char *)"new__DataType_Vec_short_2", _wrap_new__DataType_Vec_short_2, METH_VARARGS, NULL},
{ (char *)"delete__DataType_Vec_short_2", _wrap_delete__DataType_Vec_short_2, METH_VARARGS, NULL},
{ (char *)"_DataType_Vec_short_2_swigregister", _DataType_Vec_short_2_swigregister, METH_VARARGS, NULL},
{ (char *)"_Matx_short_3_1_all", _wrap__Matx_short_3_1_all, METH_VARARGS, NULL},
{ (char *)"_Matx_short_3_1_zeros", _wrap__Matx_short_3_1_zeros, METH_VARARGS, NULL},
{ (char *)"_Matx_short_3_1_ones", _wrap__Matx_short_3_1_ones, METH_VARARGS, NULL},
{ (char *)"_Matx_short_3_1_eye", _wrap__Matx_short_3_1_eye, METH_VARARGS, NULL},
{ (char *)"_Matx_short_3_1_randu", _wrap__Matx_short_3_1_randu, METH_VARARGS, NULL},
{ (char *)"_Matx_short_3_1_randn", _wrap__Matx_short_3_1_randn, METH_VARARGS, NULL},
{ (char *)"_Matx_short_3_1_dot", _wrap__Matx_short_3_1_dot, METH_VARARGS, NULL},
{ (char *)"_Matx_short_3_1_ddot", _wrap__Matx_short_3_1_ddot, METH_VARARGS, NULL},
{ (char *)"_Matx_short_3_1_t", _wrap__Matx_short_3_1_t, METH_VARARGS, NULL},
{ (char *)"_Matx_short_3_1_mul", _wrap__Matx_short_3_1_mul, METH_VARARGS, NULL},
{ (char *)"_Matx_short_3_1_div", _wrap__Matx_short_3_1_div, METH_VARARGS, NULL},
{ (char *)"_Matx_short_3_1___call__", _wrap__Matx_short_3_1___call__, METH_VARARGS, NULL},
{ (char *)"_Matx_short_3_1_val_set", _wrap__Matx_short_3_1_val_set, METH_VARARGS, NULL},
{ (char *)"_Matx_short_3_1_val_get", _wrap__Matx_short_3_1_val_get, METH_VARARGS, NULL},
{ (char *)"new__Matx_short_3_1", _wrap_new__Matx_short_3_1, METH_VARARGS, NULL},
{ (char *)"_Matx_short_3_1___str__", _wrap__Matx_short_3_1___str__, METH_VARARGS, NULL},
{ (char *)"delete__Matx_short_3_1", _wrap_delete__Matx_short_3_1, METH_VARARGS, NULL},
{ (char *)"_Matx_short_3_1_swigregister", _Matx_short_3_1_swigregister, METH_VARARGS, NULL},
{ (char *)"_Vec_short_3_all", _wrap__Vec_short_3_all, METH_VARARGS, NULL},
{ (char *)"_Vec_short_3_mul", _wrap__Vec_short_3_mul, METH_VARARGS, NULL},
{ (char *)"_Vec_short_3___call__", _wrap__Vec_short_3___call__, METH_VARARGS, NULL},
{ (char *)"new__Vec_short_3", _wrap_new__Vec_short_3, METH_VARARGS, NULL},
{ (char *)"_Vec_short_3___str__", _wrap__Vec_short_3___str__, METH_VARARGS, NULL},
{ (char *)"delete__Vec_short_3", _wrap_delete__Vec_short_3, METH_VARARGS, NULL},
{ (char *)"_Vec_short_3_swigregister", _Vec_short_3_swigregister, METH_VARARGS, NULL},
{ (char *)"new__DataType_Vec_short_3", _wrap_new__DataType_Vec_short_3, METH_VARARGS, NULL},
{ (char *)"delete__DataType_Vec_short_3", _wrap_delete__DataType_Vec_short_3, METH_VARARGS, NULL},
{ (char *)"_DataType_Vec_short_3_swigregister", _DataType_Vec_short_3_swigregister, METH_VARARGS, NULL},
{ (char *)"_Matx_short_4_1_all", _wrap__Matx_short_4_1_all, METH_VARARGS, NULL},
{ (char *)"_Matx_short_4_1_zeros", _wrap__Matx_short_4_1_zeros, METH_VARARGS, NULL},
{ (char *)"_Matx_short_4_1_ones", _wrap__Matx_short_4_1_ones, METH_VARARGS, NULL},
{ (char *)"_Matx_short_4_1_eye", _wrap__Matx_short_4_1_eye, METH_VARARGS, NULL},
{ (char *)"_Matx_short_4_1_randu", _wrap__Matx_short_4_1_randu, METH_VARARGS, NULL},
{ (char *)"_Matx_short_4_1_randn", _wrap__Matx_short_4_1_randn, METH_VARARGS, NULL},
{ (char *)"_Matx_short_4_1_dot", _wrap__Matx_short_4_1_dot, METH_VARARGS, NULL},
{ (char *)"_Matx_short_4_1_ddot", _wrap__Matx_short_4_1_ddot, METH_VARARGS, NULL},
{ (char *)"_Matx_short_4_1_t", _wrap__Matx_short_4_1_t, METH_VARARGS, NULL},
{ (char *)"_Matx_short_4_1_mul", _wrap__Matx_short_4_1_mul, METH_VARARGS, NULL},
{ (char *)"_Matx_short_4_1_div", _wrap__Matx_short_4_1_div, METH_VARARGS, NULL},
{ (char *)"_Matx_short_4_1___call__", _wrap__Matx_short_4_1___call__, METH_VARARGS, NULL},
{ (char *)"_Matx_short_4_1_val_set", _wrap__Matx_short_4_1_val_set, METH_VARARGS, NULL},
{ (char *)"_Matx_short_4_1_val_get", _wrap__Matx_short_4_1_val_get, METH_VARARGS, NULL},
{ (char *)"new__Matx_short_4_1", _wrap_new__Matx_short_4_1, METH_VARARGS, NULL},
{ (char *)"_Matx_short_4_1___str__", _wrap__Matx_short_4_1___str__, METH_VARARGS, NULL},
{ (char *)"delete__Matx_short_4_1", _wrap_delete__Matx_short_4_1, METH_VARARGS, NULL},
{ (char *)"_Matx_short_4_1_swigregister", _Matx_short_4_1_swigregister, METH_VARARGS, NULL},
{ (char *)"_Vec_short_4_all", _wrap__Vec_short_4_all, METH_VARARGS, NULL},
{ (char *)"_Vec_short_4_mul", _wrap__Vec_short_4_mul, METH_VARARGS, NULL},
{ (char *)"_Vec_short_4___call__", _wrap__Vec_short_4___call__, METH_VARARGS, NULL},
{ (char *)"new__Vec_short_4", _wrap_new__Vec_short_4, METH_VARARGS, NULL},
{ (char *)"_Vec_short_4___str__", _wrap__Vec_short_4___str__, METH_VARARGS, NULL},
{ (char *)"delete__Vec_short_4", _wrap_delete__Vec_short_4, METH_VARARGS, NULL},
{ (char *)"_Vec_short_4_swigregister", _Vec_short_4_swigregister, METH_VARARGS, NULL},
{ (char *)"new__DataType_Vec_short_4", _wrap_new__DataType_Vec_short_4, METH_VARARGS, NULL},
{ (char *)"delete__DataType_Vec_short_4", _wrap_delete__DataType_Vec_short_4, METH_VARARGS, NULL},
{ (char *)"_DataType_Vec_short_4_swigregister", _DataType_Vec_short_4_swigregister, METH_VARARGS, NULL},
{ (char *)"new__cv_numpy_sizeof_ushort", _wrap_new__cv_numpy_sizeof_ushort, METH_VARARGS, NULL},
{ (char *)"delete__cv_numpy_sizeof_ushort", _wrap_delete__cv_numpy_sizeof_ushort, METH_VARARGS, NULL},
{ (char *)"_cv_numpy_sizeof_ushort_swigregister", _cv_numpy_sizeof_ushort_swigregister, METH_VARARGS, NULL},
{ (char *)"_ushortArray_iterator", _wrap__ushortArray_iterator, METH_VARARGS, NULL},
{ (char *)"_ushortArray___nonzero__", _wrap__ushortArray___nonzero__, METH_VARARGS, NULL},
{ (char *)"_ushortArray___bool__", _wrap__ushortArray___bool__, METH_VARARGS, NULL},
{ (char *)"_ushortArray___len__", _wrap__ushortArray___len__, METH_VARARGS, NULL},
{ (char *)"_ushortArray___getslice__", _wrap__ushortArray___getslice__, METH_VARARGS, NULL},
{ (char *)"_ushortArray___setslice__", _wrap__ushortArray___setslice__, METH_VARARGS, NULL},
{ (char *)"_ushortArray___delslice__", _wrap__ushortArray___delslice__, METH_VARARGS, NULL},
{ (char *)"_ushortArray___delitem__", _wrap__ushortArray___delitem__, METH_VARARGS, NULL},
{ (char *)"_ushortArray___getitem__", _wrap__ushortArray___getitem__, METH_VARARGS, NULL},
{ (char *)"_ushortArray___setitem__", _wrap__ushortArray___setitem__, METH_VARARGS, NULL},
{ (char *)"_ushortArray_pop", _wrap__ushortArray_pop, METH_VARARGS, NULL},
{ (char *)"_ushortArray_append", _wrap__ushortArray_append, METH_VARARGS, NULL},
{ (char *)"_ushortArray_empty", _wrap__ushortArray_empty, METH_VARARGS, NULL},
{ (char *)"_ushortArray_size", _wrap__ushortArray_size, METH_VARARGS, NULL},
{ (char *)"_ushortArray_swap", _wrap__ushortArray_swap, METH_VARARGS, NULL},
{ (char *)"_ushortArray_begin", _wrap__ushortArray_begin, METH_VARARGS, NULL},
{ (char *)"_ushortArray_end", _wrap__ushortArray_end, METH_VARARGS, NULL},
{ (char *)"_ushortArray_rbegin", _wrap__ushortArray_rbegin, METH_VARARGS, NULL},
{ (char *)"_ushortArray_rend", _wrap__ushortArray_rend, METH_VARARGS, NULL},
{ (char *)"_ushortArray_clear", _wrap__ushortArray_clear, METH_VARARGS, NULL},
{ (char *)"_ushortArray_get_allocator", _wrap__ushortArray_get_allocator, METH_VARARGS, NULL},
{ (char *)"_ushortArray_pop_back", _wrap__ushortArray_pop_back, METH_VARARGS, NULL},
{ (char *)"_ushortArray_erase", _wrap__ushortArray_erase, METH_VARARGS, NULL},
{ (char *)"new__ushortArray", _wrap_new__ushortArray, METH_VARARGS, NULL},
{ (char *)"_ushortArray_push_back", _wrap__ushortArray_push_back, METH_VARARGS, NULL},
{ (char *)"_ushortArray_front", _wrap__ushortArray_front, METH_VARARGS, NULL},
{ (char *)"_ushortArray_back", _wrap__ushortArray_back, METH_VARARGS, NULL},
{ (char *)"_ushortArray_assign", _wrap__ushortArray_assign, METH_VARARGS, NULL},
{ (char *)"_ushortArray_resize", _wrap__ushortArray_resize, METH_VARARGS, NULL},
{ (char *)"_ushortArray_insert", _wrap__ushortArray_insert, METH_VARARGS, NULL},
{ (char *)"_ushortArray_reserve", _wrap__ushortArray_reserve, METH_VARARGS, NULL},
{ (char *)"_ushortArray_capacity", _wrap__ushortArray_capacity, METH_VARARGS, NULL},
{ (char *)"delete__ushortArray", _wrap_delete__ushortArray, METH_VARARGS, NULL},
{ (char *)"_ushortArray_swigregister", _ushortArray_swigregister, METH_VARARGS, NULL},
{ (char *)"_Matx_ushort_2_1_all", _wrap__Matx_ushort_2_1_all, METH_VARARGS, NULL},
{ (char *)"_Matx_ushort_2_1_zeros", _wrap__Matx_ushort_2_1_zeros, METH_VARARGS, NULL},
{ (char *)"_Matx_ushort_2_1_ones", _wrap__Matx_ushort_2_1_ones, METH_VARARGS, NULL},
{ (char *)"_Matx_ushort_2_1_eye", _wrap__Matx_ushort_2_1_eye, METH_VARARGS, NULL},
{ (char *)"_Matx_ushort_2_1_randu", _wrap__Matx_ushort_2_1_randu, METH_VARARGS, NULL},
{ (char *)"_Matx_ushort_2_1_randn", _wrap__Matx_ushort_2_1_randn, METH_VARARGS, NULL},
{ (char *)"_Matx_ushort_2_1_dot", _wrap__Matx_ushort_2_1_dot, METH_VARARGS, NULL},
{ (char *)"_Matx_ushort_2_1_ddot", _wrap__Matx_ushort_2_1_ddot, METH_VARARGS, NULL},
{ (char *)"_Matx_ushort_2_1_t", _wrap__Matx_ushort_2_1_t, METH_VARARGS, NULL},
{ (char *)"_Matx_ushort_2_1_mul", _wrap__Matx_ushort_2_1_mul, METH_VARARGS, NULL},
{ (char *)"_Matx_ushort_2_1_div", _wrap__Matx_ushort_2_1_div, METH_VARARGS, NULL},
{ (char *)"_Matx_ushort_2_1___call__", _wrap__Matx_ushort_2_1___call__, METH_VARARGS, NULL},
{ (char *)"_Matx_ushort_2_1_val_set", _wrap__Matx_ushort_2_1_val_set, METH_VARARGS, NULL},
{ (char *)"_Matx_ushort_2_1_val_get", _wrap__Matx_ushort_2_1_val_get, METH_VARARGS, NULL},
{ (char *)"new__Matx_ushort_2_1", _wrap_new__Matx_ushort_2_1, METH_VARARGS, NULL},
{ (char *)"_Matx_ushort_2_1___str__", _wrap__Matx_ushort_2_1___str__, METH_VARARGS, NULL},
{ (char *)"delete__Matx_ushort_2_1", _wrap_delete__Matx_ushort_2_1, METH_VARARGS, NULL},
{ (char *)"_Matx_ushort_2_1_swigregister", _Matx_ushort_2_1_swigregister, METH_VARARGS, NULL},
{ (char *)"_Vec_ushort_2_all", _wrap__Vec_ushort_2_all, METH_VARARGS, NULL},
{ (char *)"_Vec_ushort_2_mul", _wrap__Vec_ushort_2_mul, METH_VARARGS, NULL},
{ (char *)"_Vec_ushort_2___call__", _wrap__Vec_ushort_2___call__, METH_VARARGS, NULL},
{ (char *)"new__Vec_ushort_2", _wrap_new__Vec_ushort_2, METH_VARARGS, NULL},
{ (char *)"_Vec_ushort_2___str__", _wrap__Vec_ushort_2___str__, METH_VARARGS, NULL},
{ (char *)"delete__Vec_ushort_2", _wrap_delete__Vec_ushort_2, METH_VARARGS, NULL},
{ (char *)"_Vec_ushort_2_swigregister", _Vec_ushort_2_swigregister, METH_VARARGS, NULL},
{ (char *)"new__DataType_Vec_ushort_2", _wrap_new__DataType_Vec_ushort_2, METH_VARARGS, NULL},
{ (char *)"delete__DataType_Vec_ushort_2", _wrap_delete__DataType_Vec_ushort_2, METH_VARARGS, NULL},
{ (char *)"_DataType_Vec_ushort_2_swigregister", _DataType_Vec_ushort_2_swigregister, METH_VARARGS, NULL},
{ (char *)"_Matx_ushort_3_1_all", _wrap__Matx_ushort_3_1_all, METH_VARARGS, NULL},
{ (char *)"_Matx_ushort_3_1_zeros", _wrap__Matx_ushort_3_1_zeros, METH_VARARGS, NULL},
{ (char *)"_Matx_ushort_3_1_ones", _wrap__Matx_ushort_3_1_ones, METH_VARARGS, NULL},
{ (char *)"_Matx_ushort_3_1_eye", _wrap__Matx_ushort_3_1_eye, METH_VARARGS, NULL},
{ (char *)"_Matx_ushort_3_1_randu", _wrap__Matx_ushort_3_1_randu, METH_VARARGS, NULL},
{ (char *)"_Matx_ushort_3_1_randn", _wrap__Matx_ushort_3_1_randn, METH_VARARGS, NULL},
{ (char *)"_Matx_ushort_3_1_dot", _wrap__Matx_ushort_3_1_dot, METH_VARARGS, NULL},
{ (char *)"_Matx_ushort_3_1_ddot", _wrap__Matx_ushort_3_1_ddot, METH_VARARGS, NULL},
{ (char *)"_Matx_ushort_3_1_t", _wrap__Matx_ushort_3_1_t, METH_VARARGS, NULL},
{ (char *)"_Matx_ushort_3_1_mul", _wrap__Matx_ushort_3_1_mul, METH_VARARGS, NULL},
{ (char *)"_Matx_ushort_3_1_div", _wrap__Matx_ushort_3_1_div, METH_VARARGS, NULL},
{ (char *)"_Matx_ushort_3_1___call__", _wrap__Matx_ushort_3_1___call__, METH_VARARGS, NULL},
{ (char *)"_Matx_ushort_3_1_val_set", _wrap__Matx_ushort_3_1_val_set, METH_VARARGS, NULL},
{ (char *)"_Matx_ushort_3_1_val_get", _wrap__Matx_ushort_3_1_val_get, METH_VARARGS, NULL},
{ (char *)"new__Matx_ushort_3_1", _wrap_new__Matx_ushort_3_1, METH_VARARGS, NULL},
{ (char *)"_Matx_ushort_3_1___str__", _wrap__Matx_ushort_3_1___str__, METH_VARARGS, NULL},
{ (char *)"delete__Matx_ushort_3_1", _wrap_delete__Matx_ushort_3_1, METH_VARARGS, NULL},
{ (char *)"_Matx_ushort_3_1_swigregister", _Matx_ushort_3_1_swigregister, METH_VARARGS, NULL},
{ (char *)"_Vec_ushort_3_all", _wrap__Vec_ushort_3_all, METH_VARARGS, NULL},
{ (char *)"_Vec_ushort_3_mul", _wrap__Vec_ushort_3_mul, METH_VARARGS, NULL},
{ (char *)"_Vec_ushort_3___call__", _wrap__Vec_ushort_3___call__, METH_VARARGS, NULL},
{ (char *)"new__Vec_ushort_3", _wrap_new__Vec_ushort_3, METH_VARARGS, NULL},
{ (char *)"_Vec_ushort_3___str__", _wrap__Vec_ushort_3___str__, METH_VARARGS, NULL},
{ (char *)"delete__Vec_ushort_3", _wrap_delete__Vec_ushort_3, METH_VARARGS, NULL},
{ (char *)"_Vec_ushort_3_swigregister", _Vec_ushort_3_swigregister, METH_VARARGS, NULL},
{ (char *)"new__DataType_Vec_ushort_3", _wrap_new__DataType_Vec_ushort_3, METH_VARARGS, NULL},
{ (char *)"delete__DataType_Vec_ushort_3", _wrap_delete__DataType_Vec_ushort_3, METH_VARARGS, NULL},
{ (char *)"_DataType_Vec_ushort_3_swigregister", _DataType_Vec_ushort_3_swigregister, METH_VARARGS, NULL},
{ (char *)"_Matx_ushort_4_1_all", _wrap__Matx_ushort_4_1_all, METH_VARARGS, NULL},
{ (char *)"_Matx_ushort_4_1_zeros", _wrap__Matx_ushort_4_1_zeros, METH_VARARGS, NULL},
{ (char *)"_Matx_ushort_4_1_ones", _wrap__Matx_ushort_4_1_ones, METH_VARARGS, NULL},
{ (char *)"_Matx_ushort_4_1_eye", _wrap__Matx_ushort_4_1_eye, METH_VARARGS, NULL},
{ (char *)"_Matx_ushort_4_1_randu", _wrap__Matx_ushort_4_1_randu, METH_VARARGS, NULL},
{ (char *)"_Matx_ushort_4_1_randn", _wrap__Matx_ushort_4_1_randn, METH_VARARGS, NULL},
{ (char *)"_Matx_ushort_4_1_dot", _wrap__Matx_ushort_4_1_dot, METH_VARARGS, NULL},
{ (char *)"_Matx_ushort_4_1_ddot", _wrap__Matx_ushort_4_1_ddot, METH_VARARGS, NULL},
{ (char *)"_Matx_ushort_4_1_t", _wrap__Matx_ushort_4_1_t, METH_VARARGS, NULL},
{ (char *)"_Matx_ushort_4_1_mul", _wrap__Matx_ushort_4_1_mul, METH_VARARGS, NULL},
{ (char *)"_Matx_ushort_4_1_div", _wrap__Matx_ushort_4_1_div, METH_VARARGS, NULL},
{ (char *)"_Matx_ushort_4_1___call__", _wrap__Matx_ushort_4_1___call__, METH_VARARGS, NULL},
{ (char *)"_Matx_ushort_4_1_val_set", _wrap__Matx_ushort_4_1_val_set, METH_VARARGS, NULL},
{ (char *)"_Matx_ushort_4_1_val_get", _wrap__Matx_ushort_4_1_val_get, METH_VARARGS, NULL},
{ (char *)"new__Matx_ushort_4_1", _wrap_new__Matx_ushort_4_1, METH_VARARGS, NULL},
{ (char *)"_Matx_ushort_4_1___str__", _wrap__Matx_ushort_4_1___str__, METH_VARARGS, NULL},
{ (char *)"delete__Matx_ushort_4_1", _wrap_delete__Matx_ushort_4_1, METH_VARARGS, NULL},
{ (char *)"_Matx_ushort_4_1_swigregister", _Matx_ushort_4_1_swigregister, METH_VARARGS, NULL},
{ (char *)"_Vec_ushort_4_all", _wrap__Vec_ushort_4_all, METH_VARARGS, NULL},
{ (char *)"_Vec_ushort_4_mul", _wrap__Vec_ushort_4_mul, METH_VARARGS, NULL},
{ (char *)"_Vec_ushort_4___call__", _wrap__Vec_ushort_4___call__, METH_VARARGS, NULL},
{ (char *)"new__Vec_ushort_4", _wrap_new__Vec_ushort_4, METH_VARARGS, NULL},
{ (char *)"_Vec_ushort_4___str__", _wrap__Vec_ushort_4___str__, METH_VARARGS, NULL},
{ (char *)"delete__Vec_ushort_4", _wrap_delete__Vec_ushort_4, METH_VARARGS, NULL},
{ (char *)"_Vec_ushort_4_swigregister", _Vec_ushort_4_swigregister, METH_VARARGS, NULL},
{ (char *)"new__DataType_Vec_ushort_4", _wrap_new__DataType_Vec_ushort_4, METH_VARARGS, NULL},
{ (char *)"delete__DataType_Vec_ushort_4", _wrap_delete__DataType_Vec_ushort_4, METH_VARARGS, NULL},
{ (char *)"_DataType_Vec_ushort_4_swigregister", _DataType_Vec_ushort_4_swigregister, METH_VARARGS, NULL},
{ (char *)"new__cv_numpy_sizeof_int", _wrap_new__cv_numpy_sizeof_int, METH_VARARGS, NULL},
{ (char *)"delete__cv_numpy_sizeof_int", _wrap_delete__cv_numpy_sizeof_int, METH_VARARGS, NULL},
{ (char *)"_cv_numpy_sizeof_int_swigregister", _cv_numpy_sizeof_int_swigregister, METH_VARARGS, NULL},
{ (char *)"_intArray_iterator", _wrap__intArray_iterator, METH_VARARGS, NULL},
{ (char *)"_intArray___nonzero__", _wrap__intArray___nonzero__, METH_VARARGS, NULL},
{ (char *)"_intArray___bool__", _wrap__intArray___bool__, METH_VARARGS, NULL},
{ (char *)"_intArray___len__", _wrap__intArray___len__, METH_VARARGS, NULL},
{ (char *)"_intArray___getslice__", _wrap__intArray___getslice__, METH_VARARGS, NULL},
{ (char *)"_intArray___setslice__", _wrap__intArray___setslice__, METH_VARARGS, NULL},
{ (char *)"_intArray___delslice__", _wrap__intArray___delslice__, METH_VARARGS, NULL},
{ (char *)"_intArray___delitem__", _wrap__intArray___delitem__, METH_VARARGS, NULL},
{ (char *)"_intArray___getitem__", _wrap__intArray___getitem__, METH_VARARGS, NULL},
{ (char *)"_intArray___setitem__", _wrap__intArray___setitem__, METH_VARARGS, NULL},
{ (char *)"_intArray_pop", _wrap__intArray_pop, METH_VARARGS, NULL},
{ (char *)"_intArray_append", _wrap__intArray_append, METH_VARARGS, NULL},
{ (char *)"_intArray_empty", _wrap__intArray_empty, METH_VARARGS, NULL},
{ (char *)"_intArray_size", _wrap__intArray_size, METH_VARARGS, NULL},
{ (char *)"_intArray_swap", _wrap__intArray_swap, METH_VARARGS, NULL},
{ (char *)"_intArray_begin", _wrap__intArray_begin, METH_VARARGS, NULL},
{ (char *)"_intArray_end", _wrap__intArray_end, METH_VARARGS, NULL},
{ (char *)"_intArray_rbegin", _wrap__intArray_rbegin, METH_VARARGS, NULL},
{ (char *)"_intArray_rend", _wrap__intArray_rend, METH_VARARGS, NULL},
{ (char *)"_intArray_clear", _wrap__intArray_clear, METH_VARARGS, NULL},
{ (char *)"_intArray_get_allocator", _wrap__intArray_get_allocator, METH_VARARGS, NULL},
{ (char *)"_intArray_pop_back", _wrap__intArray_pop_back, METH_VARARGS, NULL},
{ (char *)"_intArray_erase", _wrap__intArray_erase, METH_VARARGS, NULL},
{ (char *)"new__intArray", _wrap_new__intArray, METH_VARARGS, NULL},
{ (char *)"_intArray_push_back", _wrap__intArray_push_back, METH_VARARGS, NULL},
{ (char *)"_intArray_front", _wrap__intArray_front, METH_VARARGS, NULL},
{ (char *)"_intArray_back", _wrap__intArray_back, METH_VARARGS, NULL},
{ (char *)"_intArray_assign", _wrap__intArray_assign, METH_VARARGS, NULL},
{ (char *)"_intArray_resize", _wrap__intArray_resize, METH_VARARGS, NULL},
{ (char *)"_intArray_insert", _wrap__intArray_insert, METH_VARARGS, NULL},
{ (char *)"_intArray_reserve", _wrap__intArray_reserve, METH_VARARGS, NULL},
{ (char *)"_intArray_capacity", _wrap__intArray_capacity, METH_VARARGS, NULL},
{ (char *)"delete__intArray", _wrap_delete__intArray, METH_VARARGS, NULL},
{ (char *)"_intArray_swigregister", _intArray_swigregister, METH_VARARGS, NULL},
{ (char *)"_Matx_int_2_1_all", _wrap__Matx_int_2_1_all, METH_VARARGS, NULL},
{ (char *)"_Matx_int_2_1_zeros", _wrap__Matx_int_2_1_zeros, METH_VARARGS, NULL},
{ (char *)"_Matx_int_2_1_ones", _wrap__Matx_int_2_1_ones, METH_VARARGS, NULL},
{ (char *)"_Matx_int_2_1_eye", _wrap__Matx_int_2_1_eye, METH_VARARGS, NULL},
{ (char *)"_Matx_int_2_1_randu", _wrap__Matx_int_2_1_randu, METH_VARARGS, NULL},
{ (char *)"_Matx_int_2_1_randn", _wrap__Matx_int_2_1_randn, METH_VARARGS, NULL},
{ (char *)"_Matx_int_2_1_dot", _wrap__Matx_int_2_1_dot, METH_VARARGS, NULL},
{ (char *)"_Matx_int_2_1_ddot", _wrap__Matx_int_2_1_ddot, METH_VARARGS, NULL},
{ (char *)"_Matx_int_2_1_t", _wrap__Matx_int_2_1_t, METH_VARARGS, NULL},
{ (char *)"_Matx_int_2_1_mul", _wrap__Matx_int_2_1_mul, METH_VARARGS, NULL},
{ (char *)"_Matx_int_2_1_div", _wrap__Matx_int_2_1_div, METH_VARARGS, NULL},
{ (char *)"_Matx_int_2_1___call__", _wrap__Matx_int_2_1___call__, METH_VARARGS, NULL},
{ (char *)"_Matx_int_2_1_val_set", _wrap__Matx_int_2_1_val_set, METH_VARARGS, NULL},
{ (char *)"_Matx_int_2_1_val_get", _wrap__Matx_int_2_1_val_get, METH_VARARGS, NULL},
{ (char *)"new__Matx_int_2_1", _wrap_new__Matx_int_2_1, METH_VARARGS, NULL},
{ (char *)"_Matx_int_2_1___str__", _wrap__Matx_int_2_1___str__, METH_VARARGS, NULL},
{ (char *)"delete__Matx_int_2_1", _wrap_delete__Matx_int_2_1, METH_VARARGS, NULL},
{ (char *)"_Matx_int_2_1_swigregister", _Matx_int_2_1_swigregister, METH_VARARGS, NULL},
{ (char *)"_Vec_int_2_all", _wrap__Vec_int_2_all, METH_VARARGS, NULL},
{ (char *)"_Vec_int_2_mul", _wrap__Vec_int_2_mul, METH_VARARGS, NULL},
{ (char *)"_Vec_int_2___call__", _wrap__Vec_int_2___call__, METH_VARARGS, NULL},
{ (char *)"new__Vec_int_2", _wrap_new__Vec_int_2, METH_VARARGS, NULL},
{ (char *)"_Vec_int_2___str__", _wrap__Vec_int_2___str__, METH_VARARGS, NULL},
{ (char *)"delete__Vec_int_2", _wrap_delete__Vec_int_2, METH_VARARGS, NULL},
{ (char *)"_Vec_int_2_swigregister", _Vec_int_2_swigregister, METH_VARARGS, NULL},
{ (char *)"new__DataType_Vec_int_2", _wrap_new__DataType_Vec_int_2, METH_VARARGS, NULL},
{ (char *)"delete__DataType_Vec_int_2", _wrap_delete__DataType_Vec_int_2, METH_VARARGS, NULL},
{ (char *)"_DataType_Vec_int_2_swigregister", _DataType_Vec_int_2_swigregister, METH_VARARGS, NULL},
{ (char *)"_Matx_int_3_1_all", _wrap__Matx_int_3_1_all, METH_VARARGS, NULL},
{ (char *)"_Matx_int_3_1_zeros", _wrap__Matx_int_3_1_zeros, METH_VARARGS, NULL},
{ (char *)"_Matx_int_3_1_ones", _wrap__Matx_int_3_1_ones, METH_VARARGS, NULL},
{ (char *)"_Matx_int_3_1_eye", _wrap__Matx_int_3_1_eye, METH_VARARGS, NULL},
{ (char *)"_Matx_int_3_1_randu", _wrap__Matx_int_3_1_randu, METH_VARARGS, NULL},
{ (char *)"_Matx_int_3_1_randn", _wrap__Matx_int_3_1_randn, METH_VARARGS, NULL},
{ (char *)"_Matx_int_3_1_dot", _wrap__Matx_int_3_1_dot, METH_VARARGS, NULL},
{ (char *)"_Matx_int_3_1_ddot", _wrap__Matx_int_3_1_ddot, METH_VARARGS, NULL},
{ (char *)"_Matx_int_3_1_t", _wrap__Matx_int_3_1_t, METH_VARARGS, NULL},
{ (char *)"_Matx_int_3_1_mul", _wrap__Matx_int_3_1_mul, METH_VARARGS, NULL},
{ (char *)"_Matx_int_3_1_div", _wrap__Matx_int_3_1_div, METH_VARARGS, NULL},
{ (char *)"_Matx_int_3_1___call__", _wrap__Matx_int_3_1___call__, METH_VARARGS, NULL},
{ (char *)"_Matx_int_3_1_val_set", _wrap__Matx_int_3_1_val_set, METH_VARARGS, NULL},
{ (char *)"_Matx_int_3_1_val_get", _wrap__Matx_int_3_1_val_get, METH_VARARGS, NULL},
{ (char *)"new__Matx_int_3_1", _wrap_new__Matx_int_3_1, METH_VARARGS, NULL},
{ (char *)"_Matx_int_3_1___str__", _wrap__Matx_int_3_1___str__, METH_VARARGS, NULL},
{ (char *)"delete__Matx_int_3_1", _wrap_delete__Matx_int_3_1, METH_VARARGS, NULL},
{ (char *)"_Matx_int_3_1_swigregister", _Matx_int_3_1_swigregister, METH_VARARGS, NULL},
{ (char *)"_Vec_int_3_all", _wrap__Vec_int_3_all, METH_VARARGS, NULL},
{ (char *)"_Vec_int_3_mul", _wrap__Vec_int_3_mul, METH_VARARGS, NULL},
{ (char *)"_Vec_int_3___call__", _wrap__Vec_int_3___call__, METH_VARARGS, NULL},
{ (char *)"new__Vec_int_3", _wrap_new__Vec_int_3, METH_VARARGS, NULL},
{ (char *)"_Vec_int_3___str__", _wrap__Vec_int_3___str__, METH_VARARGS, NULL},
{ (char *)"delete__Vec_int_3", _wrap_delete__Vec_int_3, METH_VARARGS, NULL},
{ (char *)"_Vec_int_3_swigregister", _Vec_int_3_swigregister, METH_VARARGS, NULL},
{ (char *)"new__DataType_Vec_int_3", _wrap_new__DataType_Vec_int_3, METH_VARARGS, NULL},
{ (char *)"delete__DataType_Vec_int_3", _wrap_delete__DataType_Vec_int_3, METH_VARARGS, NULL},
{ (char *)"_DataType_Vec_int_3_swigregister", _DataType_Vec_int_3_swigregister, METH_VARARGS, NULL},
{ (char *)"_Matx_int_4_1_all", _wrap__Matx_int_4_1_all, METH_VARARGS, NULL},
{ (char *)"_Matx_int_4_1_zeros", _wrap__Matx_int_4_1_zeros, METH_VARARGS, NULL},
{ (char *)"_Matx_int_4_1_ones", _wrap__Matx_int_4_1_ones, METH_VARARGS, NULL},
{ (char *)"_Matx_int_4_1_eye", _wrap__Matx_int_4_1_eye, METH_VARARGS, NULL},
{ (char *)"_Matx_int_4_1_randu", _wrap__Matx_int_4_1_randu, METH_VARARGS, NULL},
{ (char *)"_Matx_int_4_1_randn", _wrap__Matx_int_4_1_randn, METH_VARARGS, NULL},
{ (char *)"_Matx_int_4_1_dot", _wrap__Matx_int_4_1_dot, METH_VARARGS, NULL},
{ (char *)"_Matx_int_4_1_ddot", _wrap__Matx_int_4_1_ddot, METH_VARARGS, NULL},
{ (char *)"_Matx_int_4_1_t", _wrap__Matx_int_4_1_t, METH_VARARGS, NULL},
{ (char *)"_Matx_int_4_1_mul", _wrap__Matx_int_4_1_mul, METH_VARARGS, NULL},
{ (char *)"_Matx_int_4_1_div", _wrap__Matx_int_4_1_div, METH_VARARGS, NULL},
{ (char *)"_Matx_int_4_1___call__", _wrap__Matx_int_4_1___call__, METH_VARARGS, NULL},
{ (char *)"_Matx_int_4_1_val_set", _wrap__Matx_int_4_1_val_set, METH_VARARGS, NULL},
{ (char *)"_Matx_int_4_1_val_get", _wrap__Matx_int_4_1_val_get, METH_VARARGS, NULL},
{ (char *)"new__Matx_int_4_1", _wrap_new__Matx_int_4_1, METH_VARARGS, NULL},
{ (char *)"_Matx_int_4_1___str__", _wrap__Matx_int_4_1___str__, METH_VARARGS, NULL},
{ (char *)"delete__Matx_int_4_1", _wrap_delete__Matx_int_4_1, METH_VARARGS, NULL},
{ (char *)"_Matx_int_4_1_swigregister", _Matx_int_4_1_swigregister, METH_VARARGS, NULL},
{ (char *)"_Vec_int_4_all", _wrap__Vec_int_4_all, METH_VARARGS, NULL},
{ (char *)"_Vec_int_4_mul", _wrap__Vec_int_4_mul, METH_VARARGS, NULL},
{ (char *)"_Vec_int_4___call__", _wrap__Vec_int_4___call__, METH_VARARGS, NULL},
{ (char *)"new__Vec_int_4", _wrap_new__Vec_int_4, METH_VARARGS, NULL},
{ (char *)"_Vec_int_4___str__", _wrap__Vec_int_4___str__, METH_VARARGS, NULL},
{ (char *)"delete__Vec_int_4", _wrap_delete__Vec_int_4, METH_VARARGS, NULL},
{ (char *)"_Vec_int_4_swigregister", _Vec_int_4_swigregister, METH_VARARGS, NULL},
{ (char *)"new__DataType_Vec_int_4", _wrap_new__DataType_Vec_int_4, METH_VARARGS, NULL},
{ (char *)"delete__DataType_Vec_int_4", _wrap_delete__DataType_Vec_int_4, METH_VARARGS, NULL},
{ (char *)"_DataType_Vec_int_4_swigregister", _DataType_Vec_int_4_swigregister, METH_VARARGS, NULL},
{ (char *)"_Matx_int_6_1_all", _wrap__Matx_int_6_1_all, METH_VARARGS, NULL},
{ (char *)"_Matx_int_6_1_zeros", _wrap__Matx_int_6_1_zeros, METH_VARARGS, NULL},
{ (char *)"_Matx_int_6_1_ones", _wrap__Matx_int_6_1_ones, METH_VARARGS, NULL},
{ (char *)"_Matx_int_6_1_eye", _wrap__Matx_int_6_1_eye, METH_VARARGS, NULL},
{ (char *)"_Matx_int_6_1_randu", _wrap__Matx_int_6_1_randu, METH_VARARGS, NULL},
{ (char *)"_Matx_int_6_1_randn", _wrap__Matx_int_6_1_randn, METH_VARARGS, NULL},
{ (char *)"_Matx_int_6_1_dot", _wrap__Matx_int_6_1_dot, METH_VARARGS, NULL},
{ (char *)"_Matx_int_6_1_ddot", _wrap__Matx_int_6_1_ddot, METH_VARARGS, NULL},
{ (char *)"_Matx_int_6_1_t", _wrap__Matx_int_6_1_t, METH_VARARGS, NULL},
{ (char *)"_Matx_int_6_1_mul", _wrap__Matx_int_6_1_mul, METH_VARARGS, NULL},
{ (char *)"_Matx_int_6_1_div", _wrap__Matx_int_6_1_div, METH_VARARGS, NULL},
{ (char *)"_Matx_int_6_1___call__", _wrap__Matx_int_6_1___call__, METH_VARARGS, NULL},
{ (char *)"_Matx_int_6_1_val_set", _wrap__Matx_int_6_1_val_set, METH_VARARGS, NULL},
{ (char *)"_Matx_int_6_1_val_get", _wrap__Matx_int_6_1_val_get, METH_VARARGS, NULL},
{ (char *)"new__Matx_int_6_1", _wrap_new__Matx_int_6_1, METH_VARARGS, NULL},
{ (char *)"_Matx_int_6_1___str__", _wrap__Matx_int_6_1___str__, METH_VARARGS, NULL},
{ (char *)"delete__Matx_int_6_1", _wrap_delete__Matx_int_6_1, METH_VARARGS, NULL},
{ (char *)"_Matx_int_6_1_swigregister", _Matx_int_6_1_swigregister, METH_VARARGS, NULL},
{ (char *)"_Vec_int_6_all", _wrap__Vec_int_6_all, METH_VARARGS, NULL},
{ (char *)"_Vec_int_6_mul", _wrap__Vec_int_6_mul, METH_VARARGS, NULL},
{ (char *)"_Vec_int_6___call__", _wrap__Vec_int_6___call__, METH_VARARGS, NULL},
{ (char *)"new__Vec_int_6", _wrap_new__Vec_int_6, METH_VARARGS, NULL},
{ (char *)"_Vec_int_6___str__", _wrap__Vec_int_6___str__, METH_VARARGS, NULL},
{ (char *)"delete__Vec_int_6", _wrap_delete__Vec_int_6, METH_VARARGS, NULL},
{ (char *)"_Vec_int_6_swigregister", _Vec_int_6_swigregister, METH_VARARGS, NULL},
{ (char *)"new__DataType_Vec_int_6", _wrap_new__DataType_Vec_int_6, METH_VARARGS, NULL},
{ (char *)"delete__DataType_Vec_int_6", _wrap_delete__DataType_Vec_int_6, METH_VARARGS, NULL},
{ (char *)"_DataType_Vec_int_6_swigregister", _DataType_Vec_int_6_swigregister, METH_VARARGS, NULL},
{ (char *)"_Matx_int_8_1_all", _wrap__Matx_int_8_1_all, METH_VARARGS, NULL},
{ (char *)"_Matx_int_8_1_zeros", _wrap__Matx_int_8_1_zeros, METH_VARARGS, NULL},
{ (char *)"_Matx_int_8_1_ones", _wrap__Matx_int_8_1_ones, METH_VARARGS, NULL},
{ (char *)"_Matx_int_8_1_eye", _wrap__Matx_int_8_1_eye, METH_VARARGS, NULL},
{ (char *)"_Matx_int_8_1_randu", _wrap__Matx_int_8_1_randu, METH_VARARGS, NULL},
{ (char *)"_Matx_int_8_1_randn", _wrap__Matx_int_8_1_randn, METH_VARARGS, NULL},
{ (char *)"_Matx_int_8_1_dot", _wrap__Matx_int_8_1_dot, METH_VARARGS, NULL},
{ (char *)"_Matx_int_8_1_ddot", _wrap__Matx_int_8_1_ddot, METH_VARARGS, NULL},
{ (char *)"_Matx_int_8_1_t", _wrap__Matx_int_8_1_t, METH_VARARGS, NULL},
{ (char *)"_Matx_int_8_1_mul", _wrap__Matx_int_8_1_mul, METH_VARARGS, NULL},
{ (char *)"_Matx_int_8_1_div", _wrap__Matx_int_8_1_div, METH_VARARGS, NULL},
{ (char *)"_Matx_int_8_1___call__", _wrap__Matx_int_8_1___call__, METH_VARARGS, NULL},
{ (char *)"_Matx_int_8_1_val_set", _wrap__Matx_int_8_1_val_set, METH_VARARGS, NULL},
{ (char *)"_Matx_int_8_1_val_get", _wrap__Matx_int_8_1_val_get, METH_VARARGS, NULL},
{ (char *)"new__Matx_int_8_1", _wrap_new__Matx_int_8_1, METH_VARARGS, NULL},
{ (char *)"_Matx_int_8_1___str__", _wrap__Matx_int_8_1___str__, METH_VARARGS, NULL},
{ (char *)"delete__Matx_int_8_1", _wrap_delete__Matx_int_8_1, METH_VARARGS, NULL},
{ (char *)"_Matx_int_8_1_swigregister", _Matx_int_8_1_swigregister, METH_VARARGS, NULL},
{ (char *)"_Vec_int_8_all", _wrap__Vec_int_8_all, METH_VARARGS, NULL},
{ (char *)"_Vec_int_8_mul", _wrap__Vec_int_8_mul, METH_VARARGS, NULL},
{ (char *)"_Vec_int_8___call__", _wrap__Vec_int_8___call__, METH_VARARGS, NULL},
{ (char *)"new__Vec_int_8", _wrap_new__Vec_int_8, METH_VARARGS, NULL},
{ (char *)"_Vec_int_8___str__", _wrap__Vec_int_8___str__, METH_VARARGS, NULL},
{ (char *)"delete__Vec_int_8", _wrap_delete__Vec_int_8, METH_VARARGS, NULL},
{ (char *)"_Vec_int_8_swigregister", _Vec_int_8_swigregister, METH_VARARGS, NULL},
{ (char *)"new__DataType_Vec_int_8", _wrap_new__DataType_Vec_int_8, METH_VARARGS, NULL},
{ (char *)"delete__DataType_Vec_int_8", _wrap_delete__DataType_Vec_int_8, METH_VARARGS, NULL},
{ (char *)"_DataType_Vec_int_8_swigregister", _DataType_Vec_int_8_swigregister, METH_VARARGS, NULL},
{ (char *)"new__cv_numpy_sizeof_float", _wrap_new__cv_numpy_sizeof_float, METH_VARARGS, NULL},
{ (char *)"delete__cv_numpy_sizeof_float", _wrap_delete__cv_numpy_sizeof_float, METH_VARARGS, NULL},
{ (char *)"_cv_numpy_sizeof_float_swigregister", _cv_numpy_sizeof_float_swigregister, METH_VARARGS, NULL},
{ (char *)"_floatArray_iterator", _wrap__floatArray_iterator, METH_VARARGS, NULL},
{ (char *)"_floatArray___nonzero__", _wrap__floatArray___nonzero__, METH_VARARGS, NULL},
{ (char *)"_floatArray___bool__", _wrap__floatArray___bool__, METH_VARARGS, NULL},
{ (char *)"_floatArray___len__", _wrap__floatArray___len__, METH_VARARGS, NULL},
{ (char *)"_floatArray___getslice__", _wrap__floatArray___getslice__, METH_VARARGS, NULL},
{ (char *)"_floatArray___setslice__", _wrap__floatArray___setslice__, METH_VARARGS, NULL},
{ (char *)"_floatArray___delslice__", _wrap__floatArray___delslice__, METH_VARARGS, NULL},
{ (char *)"_floatArray___delitem__", _wrap__floatArray___delitem__, METH_VARARGS, NULL},
{ (char *)"_floatArray___getitem__", _wrap__floatArray___getitem__, METH_VARARGS, NULL},
{ (char *)"_floatArray___setitem__", _wrap__floatArray___setitem__, METH_VARARGS, NULL},
{ (char *)"_floatArray_pop", _wrap__floatArray_pop, METH_VARARGS, NULL},
{ (char *)"_floatArray_append", _wrap__floatArray_append, METH_VARARGS, NULL},
{ (char *)"_floatArray_empty", _wrap__floatArray_empty, METH_VARARGS, NULL},
{ (char *)"_floatArray_size", _wrap__floatArray_size, METH_VARARGS, NULL},
{ (char *)"_floatArray_swap", _wrap__floatArray_swap, METH_VARARGS, NULL},
{ (char *)"_floatArray_begin", _wrap__floatArray_begin, METH_VARARGS, NULL},
{ (char *)"_floatArray_end", _wrap__floatArray_end, METH_VARARGS, NULL},
{ (char *)"_floatArray_rbegin", _wrap__floatArray_rbegin, METH_VARARGS, NULL},
{ (char *)"_floatArray_rend", _wrap__floatArray_rend, METH_VARARGS, NULL},
{ (char *)"_floatArray_clear", _wrap__floatArray_clear, METH_VARARGS, NULL},
{ (char *)"_floatArray_get_allocator", _wrap__floatArray_get_allocator, METH_VARARGS, NULL},
{ (char *)"_floatArray_pop_back", _wrap__floatArray_pop_back, METH_VARARGS, NULL},
{ (char *)"_floatArray_erase", _wrap__floatArray_erase, METH_VARARGS, NULL},
{ (char *)"new__floatArray", _wrap_new__floatArray, METH_VARARGS, NULL},
{ (char *)"_floatArray_push_back", _wrap__floatArray_push_back, METH_VARARGS, NULL},
{ (char *)"_floatArray_front", _wrap__floatArray_front, METH_VARARGS, NULL},
{ (char *)"_floatArray_back", _wrap__floatArray_back, METH_VARARGS, NULL},
{ (char *)"_floatArray_assign", _wrap__floatArray_assign, METH_VARARGS, NULL},
{ (char *)"_floatArray_resize", _wrap__floatArray_resize, METH_VARARGS, NULL},
{ (char *)"_floatArray_insert", _wrap__floatArray_insert, METH_VARARGS, NULL},
{ (char *)"_floatArray_reserve", _wrap__floatArray_reserve, METH_VARARGS, NULL},
{ (char *)"_floatArray_capacity", _wrap__floatArray_capacity, METH_VARARGS, NULL},
{ (char *)"delete__floatArray", _wrap_delete__floatArray, METH_VARARGS, NULL},
{ (char *)"_floatArray_swigregister", _floatArray_swigregister, METH_VARARGS, NULL},
{ (char *)"_Matx_float_2_1_all", _wrap__Matx_float_2_1_all, METH_VARARGS, NULL},
{ (char *)"_Matx_float_2_1_zeros", _wrap__Matx_float_2_1_zeros, METH_VARARGS, NULL},
{ (char *)"_Matx_float_2_1_ones", _wrap__Matx_float_2_1_ones, METH_VARARGS, NULL},
{ (char *)"_Matx_float_2_1_eye", _wrap__Matx_float_2_1_eye, METH_VARARGS, NULL},
{ (char *)"_Matx_float_2_1_randu", _wrap__Matx_float_2_1_randu, METH_VARARGS, NULL},
{ (char *)"_Matx_float_2_1_randn", _wrap__Matx_float_2_1_randn, METH_VARARGS, NULL},
{ (char *)"_Matx_float_2_1_dot", _wrap__Matx_float_2_1_dot, METH_VARARGS, NULL},
{ (char *)"_Matx_float_2_1_ddot", _wrap__Matx_float_2_1_ddot, METH_VARARGS, NULL},
{ (char *)"_Matx_float_2_1_t", _wrap__Matx_float_2_1_t, METH_VARARGS, NULL},
{ (char *)"_Matx_float_2_1_mul", _wrap__Matx_float_2_1_mul, METH_VARARGS, NULL},
{ (char *)"_Matx_float_2_1_div", _wrap__Matx_float_2_1_div, METH_VARARGS, NULL},
{ (char *)"_Matx_float_2_1___call__", _wrap__Matx_float_2_1___call__, METH_VARARGS, NULL},
{ (char *)"_Matx_float_2_1_val_set", _wrap__Matx_float_2_1_val_set, METH_VARARGS, NULL},
{ (char *)"_Matx_float_2_1_val_get", _wrap__Matx_float_2_1_val_get, METH_VARARGS, NULL},
{ (char *)"new__Matx_float_2_1", _wrap_new__Matx_float_2_1, METH_VARARGS, NULL},
{ (char *)"_Matx_float_2_1___str__", _wrap__Matx_float_2_1___str__, METH_VARARGS, NULL},
{ (char *)"delete__Matx_float_2_1", _wrap_delete__Matx_float_2_1, METH_VARARGS, NULL},
{ (char *)"_Matx_float_2_1_swigregister", _Matx_float_2_1_swigregister, METH_VARARGS, NULL},
{ (char *)"_Vec_float_2_all", _wrap__Vec_float_2_all, METH_VARARGS, NULL},
{ (char *)"_Vec_float_2_mul", _wrap__Vec_float_2_mul, METH_VARARGS, NULL},
{ (char *)"_Vec_float_2___call__", _wrap__Vec_float_2___call__, METH_VARARGS, NULL},
{ (char *)"new__Vec_float_2", _wrap_new__Vec_float_2, METH_VARARGS, NULL},
{ (char *)"_Vec_float_2___str__", _wrap__Vec_float_2___str__, METH_VARARGS, NULL},
{ (char *)"delete__Vec_float_2", _wrap_delete__Vec_float_2, METH_VARARGS, NULL},
{ (char *)"_Vec_float_2_swigregister", _Vec_float_2_swigregister, METH_VARARGS, NULL},
{ (char *)"new__DataType_Vec_float_2", _wrap_new__DataType_Vec_float_2, METH_VARARGS, NULL},
{ (char *)"delete__DataType_Vec_float_2", _wrap_delete__DataType_Vec_float_2, METH_VARARGS, NULL},
{ (char *)"_DataType_Vec_float_2_swigregister", _DataType_Vec_float_2_swigregister, METH_VARARGS, NULL},
{ (char *)"_Matx_float_3_1_all", _wrap__Matx_float_3_1_all, METH_VARARGS, NULL},
{ (char *)"_Matx_float_3_1_zeros", _wrap__Matx_float_3_1_zeros, METH_VARARGS, NULL},
{ (char *)"_Matx_float_3_1_ones", _wrap__Matx_float_3_1_ones, METH_VARARGS, NULL},
{ (char *)"_Matx_float_3_1_eye", _wrap__Matx_float_3_1_eye, METH_VARARGS, NULL},
{ (char *)"_Matx_float_3_1_randu", _wrap__Matx_float_3_1_randu, METH_VARARGS, NULL},
{ (char *)"_Matx_float_3_1_randn", _wrap__Matx_float_3_1_randn, METH_VARARGS, NULL},
{ (char *)"_Matx_float_3_1_dot", _wrap__Matx_float_3_1_dot, METH_VARARGS, NULL},
{ (char *)"_Matx_float_3_1_ddot", _wrap__Matx_float_3_1_ddot, METH_VARARGS, NULL},
{ (char *)"_Matx_float_3_1_t", _wrap__Matx_float_3_1_t, METH_VARARGS, NULL},
{ (char *)"_Matx_float_3_1_mul", _wrap__Matx_float_3_1_mul, METH_VARARGS, NULL},
{ (char *)"_Matx_float_3_1_div", _wrap__Matx_float_3_1_div, METH_VARARGS, NULL},
{ (char *)"_Matx_float_3_1___call__", _wrap__Matx_float_3_1___call__, METH_VARARGS, NULL},
{ (char *)"_Matx_float_3_1_val_set", _wrap__Matx_float_3_1_val_set, METH_VARARGS, NULL},
{ (char *)"_Matx_float_3_1_val_get", _wrap__Matx_float_3_1_val_get, METH_VARARGS, NULL},
{ (char *)"new__Matx_float_3_1", _wrap_new__Matx_float_3_1, METH_VARARGS, NULL},
{ (char *)"_Matx_float_3_1___str__", _wrap__Matx_float_3_1___str__, METH_VARARGS, NULL},
{ (char *)"delete__Matx_float_3_1", _wrap_delete__Matx_float_3_1, METH_VARARGS, NULL},
{ (char *)"_Matx_float_3_1_swigregister", _Matx_float_3_1_swigregister, METH_VARARGS, NULL},
{ (char *)"_Vec_float_3_all", _wrap__Vec_float_3_all, METH_VARARGS, NULL},
{ (char *)"_Vec_float_3_mul", _wrap__Vec_float_3_mul, METH_VARARGS, NULL},
{ (char *)"_Vec_float_3___call__", _wrap__Vec_float_3___call__, METH_VARARGS, NULL},
{ (char *)"new__Vec_float_3", _wrap_new__Vec_float_3, METH_VARARGS, NULL},
{ (char *)"_Vec_float_3___str__", _wrap__Vec_float_3___str__, METH_VARARGS, NULL},
{ (char *)"delete__Vec_float_3", _wrap_delete__Vec_float_3, METH_VARARGS, NULL},
{ (char *)"_Vec_float_3_swigregister", _Vec_float_3_swigregister, METH_VARARGS, NULL},
{ (char *)"new__DataType_Vec_float_3", _wrap_new__DataType_Vec_float_3, METH_VARARGS, NULL},
{ (char *)"delete__DataType_Vec_float_3", _wrap_delete__DataType_Vec_float_3, METH_VARARGS, NULL},
{ (char *)"_DataType_Vec_float_3_swigregister", _DataType_Vec_float_3_swigregister, METH_VARARGS, NULL},
{ (char *)"_Matx_float_4_1_all", _wrap__Matx_float_4_1_all, METH_VARARGS, NULL},
{ (char *)"_Matx_float_4_1_zeros", _wrap__Matx_float_4_1_zeros, METH_VARARGS, NULL},
{ (char *)"_Matx_float_4_1_ones", _wrap__Matx_float_4_1_ones, METH_VARARGS, NULL},
{ (char *)"_Matx_float_4_1_eye", _wrap__Matx_float_4_1_eye, METH_VARARGS, NULL},
{ (char *)"_Matx_float_4_1_randu", _wrap__Matx_float_4_1_randu, METH_VARARGS, NULL},
{ (char *)"_Matx_float_4_1_randn", _wrap__Matx_float_4_1_randn, METH_VARARGS, NULL},
{ (char *)"_Matx_float_4_1_dot", _wrap__Matx_float_4_1_dot, METH_VARARGS, NULL},
{ (char *)"_Matx_float_4_1_ddot", _wrap__Matx_float_4_1_ddot, METH_VARARGS, NULL},
{ (char *)"_Matx_float_4_1_t", _wrap__Matx_float_4_1_t, METH_VARARGS, NULL},
{ (char *)"_Matx_float_4_1_mul", _wrap__Matx_float_4_1_mul, METH_VARARGS, NULL},
{ (char *)"_Matx_float_4_1_div", _wrap__Matx_float_4_1_div, METH_VARARGS, NULL},
{ (char *)"_Matx_float_4_1___call__", _wrap__Matx_float_4_1___call__, METH_VARARGS, NULL},
{ (char *)"_Matx_float_4_1_val_set", _wrap__Matx_float_4_1_val_set, METH_VARARGS, NULL},
{ (char *)"_Matx_float_4_1_val_get", _wrap__Matx_float_4_1_val_get, METH_VARARGS, NULL},
{ (char *)"new__Matx_float_4_1", _wrap_new__Matx_float_4_1, METH_VARARGS, NULL},
{ (char *)"_Matx_float_4_1___str__", _wrap__Matx_float_4_1___str__, METH_VARARGS, NULL},
{ (char *)"delete__Matx_float_4_1", _wrap_delete__Matx_float_4_1, METH_VARARGS, NULL},
{ (char *)"_Matx_float_4_1_swigregister", _Matx_float_4_1_swigregister, METH_VARARGS, NULL},
{ (char *)"_Vec_float_4_all", _wrap__Vec_float_4_all, METH_VARARGS, NULL},
{ (char *)"_Vec_float_4_mul", _wrap__Vec_float_4_mul, METH_VARARGS, NULL},
{ (char *)"_Vec_float_4___call__", _wrap__Vec_float_4___call__, METH_VARARGS, NULL},
{ (char *)"new__Vec_float_4", _wrap_new__Vec_float_4, METH_VARARGS, NULL},
{ (char *)"_Vec_float_4___str__", _wrap__Vec_float_4___str__, METH_VARARGS, NULL},
{ (char *)"delete__Vec_float_4", _wrap_delete__Vec_float_4, METH_VARARGS, NULL},
{ (char *)"_Vec_float_4_swigregister", _Vec_float_4_swigregister, METH_VARARGS, NULL},
{ (char *)"new__DataType_Vec_float_4", _wrap_new__DataType_Vec_float_4, METH_VARARGS, NULL},
{ (char *)"delete__DataType_Vec_float_4", _wrap_delete__DataType_Vec_float_4, METH_VARARGS, NULL},
{ (char *)"_DataType_Vec_float_4_swigregister", _DataType_Vec_float_4_swigregister, METH_VARARGS, NULL},
{ (char *)"_Matx_float_6_1_all", _wrap__Matx_float_6_1_all, METH_VARARGS, NULL},
{ (char *)"_Matx_float_6_1_zeros", _wrap__Matx_float_6_1_zeros, METH_VARARGS, NULL},
{ (char *)"_Matx_float_6_1_ones", _wrap__Matx_float_6_1_ones, METH_VARARGS, NULL},
{ (char *)"_Matx_float_6_1_eye", _wrap__Matx_float_6_1_eye, METH_VARARGS, NULL},
{ (char *)"_Matx_float_6_1_randu", _wrap__Matx_float_6_1_randu, METH_VARARGS, NULL},
{ (char *)"_Matx_float_6_1_randn", _wrap__Matx_float_6_1_randn, METH_VARARGS, NULL},
{ (char *)"_Matx_float_6_1_dot", _wrap__Matx_float_6_1_dot, METH_VARARGS, NULL},
{ (char *)"_Matx_float_6_1_ddot", _wrap__Matx_float_6_1_ddot, METH_VARARGS, NULL},
{ (char *)"_Matx_float_6_1_t", _wrap__Matx_float_6_1_t, METH_VARARGS, NULL},
{ (char *)"_Matx_float_6_1_mul", _wrap__Matx_float_6_1_mul, METH_VARARGS, NULL},
{ (char *)"_Matx_float_6_1_div", _wrap__Matx_float_6_1_div, METH_VARARGS, NULL},
{ (char *)"_Matx_float_6_1___call__", _wrap__Matx_float_6_1___call__, METH_VARARGS, NULL},
{ (char *)"_Matx_float_6_1_val_set", _wrap__Matx_float_6_1_val_set, METH_VARARGS, NULL},
{ (char *)"_Matx_float_6_1_val_get", _wrap__Matx_float_6_1_val_get, METH_VARARGS, NULL},
{ (char *)"new__Matx_float_6_1", _wrap_new__Matx_float_6_1, METH_VARARGS, NULL},
{ (char *)"_Matx_float_6_1___str__", _wrap__Matx_float_6_1___str__, METH_VARARGS, NULL},
{ (char *)"delete__Matx_float_6_1", _wrap_delete__Matx_float_6_1, METH_VARARGS, NULL},
{ (char *)"_Matx_float_6_1_swigregister", _Matx_float_6_1_swigregister, METH_VARARGS, NULL},
{ (char *)"_Vec_float_6_all", _wrap__Vec_float_6_all, METH_VARARGS, NULL},
{ (char *)"_Vec_float_6_mul", _wrap__Vec_float_6_mul, METH_VARARGS, NULL},
{ (char *)"_Vec_float_6___call__", _wrap__Vec_float_6___call__, METH_VARARGS, NULL},
{ (char *)"new__Vec_float_6", _wrap_new__Vec_float_6, METH_VARARGS, NULL},
{ (char *)"_Vec_float_6___str__", _wrap__Vec_float_6___str__, METH_VARARGS, NULL},
{ (char *)"delete__Vec_float_6", _wrap_delete__Vec_float_6, METH_VARARGS, NULL},
{ (char *)"_Vec_float_6_swigregister", _Vec_float_6_swigregister, METH_VARARGS, NULL},
{ (char *)"new__DataType_Vec_float_6", _wrap_new__DataType_Vec_float_6, METH_VARARGS, NULL},
{ (char *)"delete__DataType_Vec_float_6", _wrap_delete__DataType_Vec_float_6, METH_VARARGS, NULL},
{ (char *)"_DataType_Vec_float_6_swigregister", _DataType_Vec_float_6_swigregister, METH_VARARGS, NULL},
{ (char *)"new__cv_numpy_sizeof_double", _wrap_new__cv_numpy_sizeof_double, METH_VARARGS, NULL},
{ (char *)"delete__cv_numpy_sizeof_double", _wrap_delete__cv_numpy_sizeof_double, METH_VARARGS, NULL},
{ (char *)"_cv_numpy_sizeof_double_swigregister", _cv_numpy_sizeof_double_swigregister, METH_VARARGS, NULL},
{ (char *)"_doubleArray_iterator", _wrap__doubleArray_iterator, METH_VARARGS, NULL},
{ (char *)"_doubleArray___nonzero__", _wrap__doubleArray___nonzero__, METH_VARARGS, NULL},
{ (char *)"_doubleArray___bool__", _wrap__doubleArray___bool__, METH_VARARGS, NULL},
{ (char *)"_doubleArray___len__", _wrap__doubleArray___len__, METH_VARARGS, NULL},
{ (char *)"_doubleArray___getslice__", _wrap__doubleArray___getslice__, METH_VARARGS, NULL},
{ (char *)"_doubleArray___setslice__", _wrap__doubleArray___setslice__, METH_VARARGS, NULL},
{ (char *)"_doubleArray___delslice__", _wrap__doubleArray___delslice__, METH_VARARGS, NULL},
{ (char *)"_doubleArray___delitem__", _wrap__doubleArray___delitem__, METH_VARARGS, NULL},
{ (char *)"_doubleArray___getitem__", _wrap__doubleArray___getitem__, METH_VARARGS, NULL},
{ (char *)"_doubleArray___setitem__", _wrap__doubleArray___setitem__, METH_VARARGS, NULL},
{ (char *)"_doubleArray_pop", _wrap__doubleArray_pop, METH_VARARGS, NULL},
{ (char *)"_doubleArray_append", _wrap__doubleArray_append, METH_VARARGS, NULL},
{ (char *)"_doubleArray_empty", _wrap__doubleArray_empty, METH_VARARGS, NULL},
{ (char *)"_doubleArray_size", _wrap__doubleArray_size, METH_VARARGS, NULL},
{ (char *)"_doubleArray_swap", _wrap__doubleArray_swap, METH_VARARGS, NULL},
{ (char *)"_doubleArray_begin", _wrap__doubleArray_begin, METH_VARARGS, NULL},
{ (char *)"_doubleArray_end", _wrap__doubleArray_end, METH_VARARGS, NULL},
{ (char *)"_doubleArray_rbegin", _wrap__doubleArray_rbegin, METH_VARARGS, NULL},
{ (char *)"_doubleArray_rend", _wrap__doubleArray_rend, METH_VARARGS, NULL},
{ (char *)"_doubleArray_clear", _wrap__doubleArray_clear, METH_VARARGS, NULL},
{ (char *)"_doubleArray_get_allocator", _wrap__doubleArray_get_allocator, METH_VARARGS, NULL},
{ (char *)"_doubleArray_pop_back", _wrap__doubleArray_pop_back, METH_VARARGS, NULL},
{ (char *)"_doubleArray_erase", _wrap__doubleArray_erase, METH_VARARGS, NULL},
{ (char *)"new__doubleArray", _wrap_new__doubleArray, METH_VARARGS, NULL},
{ (char *)"_doubleArray_push_back", _wrap__doubleArray_push_back, METH_VARARGS, NULL},
{ (char *)"_doubleArray_front", _wrap__doubleArray_front, METH_VARARGS, NULL},
{ (char *)"_doubleArray_back", _wrap__doubleArray_back, METH_VARARGS, NULL},
{ (char *)"_doubleArray_assign", _wrap__doubleArray_assign, METH_VARARGS, NULL},
{ (char *)"_doubleArray_resize", _wrap__doubleArray_resize, METH_VARARGS, NULL},
{ (char *)"_doubleArray_insert", _wrap__doubleArray_insert, METH_VARARGS, NULL},
{ (char *)"_doubleArray_reserve", _wrap__doubleArray_reserve, METH_VARARGS, NULL},
{ (char *)"_doubleArray_capacity", _wrap__doubleArray_capacity, METH_VARARGS, NULL},
{ (char *)"delete__doubleArray", _wrap_delete__doubleArray, METH_VARARGS, NULL},
{ (char *)"_doubleArray_swigregister", _doubleArray_swigregister, METH_VARARGS, NULL},
{ (char *)"_Matx_double_2_1_all", _wrap__Matx_double_2_1_all, METH_VARARGS, NULL},
{ (char *)"_Matx_double_2_1_zeros", _wrap__Matx_double_2_1_zeros, METH_VARARGS, NULL},
{ (char *)"_Matx_double_2_1_ones", _wrap__Matx_double_2_1_ones, METH_VARARGS, NULL},
{ (char *)"_Matx_double_2_1_eye", _wrap__Matx_double_2_1_eye, METH_VARARGS, NULL},
{ (char *)"_Matx_double_2_1_randu", _wrap__Matx_double_2_1_randu, METH_VARARGS, NULL},
{ (char *)"_Matx_double_2_1_randn", _wrap__Matx_double_2_1_randn, METH_VARARGS, NULL},
{ (char *)"_Matx_double_2_1_dot", _wrap__Matx_double_2_1_dot, METH_VARARGS, NULL},
{ (char *)"_Matx_double_2_1_ddot", _wrap__Matx_double_2_1_ddot, METH_VARARGS, NULL},
{ (char *)"_Matx_double_2_1_t", _wrap__Matx_double_2_1_t, METH_VARARGS, NULL},
{ (char *)"_Matx_double_2_1_mul", _wrap__Matx_double_2_1_mul, METH_VARARGS, NULL},
{ (char *)"_Matx_double_2_1_div", _wrap__Matx_double_2_1_div, METH_VARARGS, NULL},
{ (char *)"_Matx_double_2_1___call__", _wrap__Matx_double_2_1___call__, METH_VARARGS, NULL},
{ (char *)"_Matx_double_2_1_val_set", _wrap__Matx_double_2_1_val_set, METH_VARARGS, NULL},
{ (char *)"_Matx_double_2_1_val_get", _wrap__Matx_double_2_1_val_get, METH_VARARGS, NULL},
{ (char *)"new__Matx_double_2_1", _wrap_new__Matx_double_2_1, METH_VARARGS, NULL},
{ (char *)"_Matx_double_2_1___str__", _wrap__Matx_double_2_1___str__, METH_VARARGS, NULL},
{ (char *)"delete__Matx_double_2_1", _wrap_delete__Matx_double_2_1, METH_VARARGS, NULL},
{ (char *)"_Matx_double_2_1_swigregister", _Matx_double_2_1_swigregister, METH_VARARGS, NULL},
{ (char *)"_Vec_double_2_all", _wrap__Vec_double_2_all, METH_VARARGS, NULL},
{ (char *)"_Vec_double_2_mul", _wrap__Vec_double_2_mul, METH_VARARGS, NULL},
{ (char *)"_Vec_double_2___call__", _wrap__Vec_double_2___call__, METH_VARARGS, NULL},
{ (char *)"new__Vec_double_2", _wrap_new__Vec_double_2, METH_VARARGS, NULL},
{ (char *)"_Vec_double_2___str__", _wrap__Vec_double_2___str__, METH_VARARGS, NULL},
{ (char *)"delete__Vec_double_2", _wrap_delete__Vec_double_2, METH_VARARGS, NULL},
{ (char *)"_Vec_double_2_swigregister", _Vec_double_2_swigregister, METH_VARARGS, NULL},
{ (char *)"new__DataType_Vec_double_2", _wrap_new__DataType_Vec_double_2, METH_VARARGS, NULL},
{ (char *)"delete__DataType_Vec_double_2", _wrap_delete__DataType_Vec_double_2, METH_VARARGS, NULL},
{ (char *)"_DataType_Vec_double_2_swigregister", _DataType_Vec_double_2_swigregister, METH_VARARGS, NULL},
{ (char *)"_Matx_double_3_1_all", _wrap__Matx_double_3_1_all, METH_VARARGS, NULL},
{ (char *)"_Matx_double_3_1_zeros", _wrap__Matx_double_3_1_zeros, METH_VARARGS, NULL},
{ (char *)"_Matx_double_3_1_ones", _wrap__Matx_double_3_1_ones, METH_VARARGS, NULL},
{ (char *)"_Matx_double_3_1_eye", _wrap__Matx_double_3_1_eye, METH_VARARGS, NULL},
{ (char *)"_Matx_double_3_1_randu", _wrap__Matx_double_3_1_randu, METH_VARARGS, NULL},
{ (char *)"_Matx_double_3_1_randn", _wrap__Matx_double_3_1_randn, METH_VARARGS, NULL},
{ (char *)"_Matx_double_3_1_dot", _wrap__Matx_double_3_1_dot, METH_VARARGS, NULL},
{ (char *)"_Matx_double_3_1_ddot", _wrap__Matx_double_3_1_ddot, METH_VARARGS, NULL},
{ (char *)"_Matx_double_3_1_t", _wrap__Matx_double_3_1_t, METH_VARARGS, NULL},
{ (char *)"_Matx_double_3_1_mul", _wrap__Matx_double_3_1_mul, METH_VARARGS, NULL},
{ (char *)"_Matx_double_3_1_div", _wrap__Matx_double_3_1_div, METH_VARARGS, NULL},
{ (char *)"_Matx_double_3_1___call__", _wrap__Matx_double_3_1___call__, METH_VARARGS, NULL},
{ (char *)"_Matx_double_3_1_val_set", _wrap__Matx_double_3_1_val_set, METH_VARARGS, NULL},
{ (char *)"_Matx_double_3_1_val_get", _wrap__Matx_double_3_1_val_get, METH_VARARGS, NULL},
{ (char *)"new__Matx_double_3_1", _wrap_new__Matx_double_3_1, METH_VARARGS, NULL},
{ (char *)"_Matx_double_3_1___str__", _wrap__Matx_double_3_1___str__, METH_VARARGS, NULL},
{ (char *)"delete__Matx_double_3_1", _wrap_delete__Matx_double_3_1, METH_VARARGS, NULL},
{ (char *)"_Matx_double_3_1_swigregister", _Matx_double_3_1_swigregister, METH_VARARGS, NULL},
{ (char *)"_Vec_double_3_all", _wrap__Vec_double_3_all, METH_VARARGS, NULL},
{ (char *)"_Vec_double_3_mul", _wrap__Vec_double_3_mul, METH_VARARGS, NULL},
{ (char *)"_Vec_double_3___call__", _wrap__Vec_double_3___call__, METH_VARARGS, NULL},
{ (char *)"new__Vec_double_3", _wrap_new__Vec_double_3, METH_VARARGS, NULL},
{ (char *)"_Vec_double_3___str__", _wrap__Vec_double_3___str__, METH_VARARGS, NULL},
{ (char *)"delete__Vec_double_3", _wrap_delete__Vec_double_3, METH_VARARGS, NULL},
{ (char *)"_Vec_double_3_swigregister", _Vec_double_3_swigregister, METH_VARARGS, NULL},
{ (char *)"new__DataType_Vec_double_3", _wrap_new__DataType_Vec_double_3, METH_VARARGS, NULL},
{ (char *)"delete__DataType_Vec_double_3", _wrap_delete__DataType_Vec_double_3, METH_VARARGS, NULL},
{ (char *)"_DataType_Vec_double_3_swigregister", _DataType_Vec_double_3_swigregister, METH_VARARGS, NULL},
{ (char *)"_Matx_double_4_1_all", _wrap__Matx_double_4_1_all, METH_VARARGS, NULL},
{ (char *)"_Matx_double_4_1_zeros", _wrap__Matx_double_4_1_zeros, METH_VARARGS, NULL},
{ (char *)"_Matx_double_4_1_ones", _wrap__Matx_double_4_1_ones, METH_VARARGS, NULL},
{ (char *)"_Matx_double_4_1_eye", _wrap__Matx_double_4_1_eye, METH_VARARGS, NULL},
{ (char *)"_Matx_double_4_1_randu", _wrap__Matx_double_4_1_randu, METH_VARARGS, NULL},
{ (char *)"_Matx_double_4_1_randn", _wrap__Matx_double_4_1_randn, METH_VARARGS, NULL},
{ (char *)"_Matx_double_4_1_dot", _wrap__Matx_double_4_1_dot, METH_VARARGS, NULL},
{ (char *)"_Matx_double_4_1_ddot", _wrap__Matx_double_4_1_ddot, METH_VARARGS, NULL},
{ (char *)"_Matx_double_4_1_t", _wrap__Matx_double_4_1_t, METH_VARARGS, NULL},
{ (char *)"_Matx_double_4_1_mul", _wrap__Matx_double_4_1_mul, METH_VARARGS, NULL},
{ (char *)"_Matx_double_4_1_div", _wrap__Matx_double_4_1_div, METH_VARARGS, NULL},
{ (char *)"_Matx_double_4_1___call__", _wrap__Matx_double_4_1___call__, METH_VARARGS, NULL},
{ (char *)"_Matx_double_4_1_val_set", _wrap__Matx_double_4_1_val_set, METH_VARARGS, NULL},
{ (char *)"_Matx_double_4_1_val_get", _wrap__Matx_double_4_1_val_get, METH_VARARGS, NULL},
{ (char *)"new__Matx_double_4_1", _wrap_new__Matx_double_4_1, METH_VARARGS, NULL},
{ (char *)"_Matx_double_4_1___str__", _wrap__Matx_double_4_1___str__, METH_VARARGS, NULL},
{ (char *)"delete__Matx_double_4_1", _wrap_delete__Matx_double_4_1, METH_VARARGS, NULL},
{ (char *)"_Matx_double_4_1_swigregister", _Matx_double_4_1_swigregister, METH_VARARGS, NULL},
{ (char *)"_Vec_double_4_all", _wrap__Vec_double_4_all, METH_VARARGS, NULL},
{ (char *)"_Vec_double_4_mul", _wrap__Vec_double_4_mul, METH_VARARGS, NULL},
{ (char *)"_Vec_double_4___call__", _wrap__Vec_double_4___call__, METH_VARARGS, NULL},
{ (char *)"new__Vec_double_4", _wrap_new__Vec_double_4, METH_VARARGS, NULL},
{ (char *)"_Vec_double_4___str__", _wrap__Vec_double_4___str__, METH_VARARGS, NULL},
{ (char *)"delete__Vec_double_4", _wrap_delete__Vec_double_4, METH_VARARGS, NULL},
{ (char *)"_Vec_double_4_swigregister", _Vec_double_4_swigregister, METH_VARARGS, NULL},
{ (char *)"new__DataType_Vec_double_4", _wrap_new__DataType_Vec_double_4, METH_VARARGS, NULL},
{ (char *)"delete__DataType_Vec_double_4", _wrap_delete__DataType_Vec_double_4, METH_VARARGS, NULL},
{ (char *)"_DataType_Vec_double_4_swigregister", _DataType_Vec_double_4_swigregister, METH_VARARGS, NULL},
{ (char *)"_Matx_double_6_1_all", _wrap__Matx_double_6_1_all, METH_VARARGS, NULL},
{ (char *)"_Matx_double_6_1_zeros", _wrap__Matx_double_6_1_zeros, METH_VARARGS, NULL},
{ (char *)"_Matx_double_6_1_ones", _wrap__Matx_double_6_1_ones, METH_VARARGS, NULL},
{ (char *)"_Matx_double_6_1_eye", _wrap__Matx_double_6_1_eye, METH_VARARGS, NULL},
{ (char *)"_Matx_double_6_1_randu", _wrap__Matx_double_6_1_randu, METH_VARARGS, NULL},
{ (char *)"_Matx_double_6_1_randn", _wrap__Matx_double_6_1_randn, METH_VARARGS, NULL},
{ (char *)"_Matx_double_6_1_dot", _wrap__Matx_double_6_1_dot, METH_VARARGS, NULL},
{ (char *)"_Matx_double_6_1_ddot", _wrap__Matx_double_6_1_ddot, METH_VARARGS, NULL},
{ (char *)"_Matx_double_6_1_t", _wrap__Matx_double_6_1_t, METH_VARARGS, NULL},
{ (char *)"_Matx_double_6_1_mul", _wrap__Matx_double_6_1_mul, METH_VARARGS, NULL},
{ (char *)"_Matx_double_6_1_div", _wrap__Matx_double_6_1_div, METH_VARARGS, NULL},
{ (char *)"_Matx_double_6_1___call__", _wrap__Matx_double_6_1___call__, METH_VARARGS, NULL},
{ (char *)"_Matx_double_6_1_val_set", _wrap__Matx_double_6_1_val_set, METH_VARARGS, NULL},
{ (char *)"_Matx_double_6_1_val_get", _wrap__Matx_double_6_1_val_get, METH_VARARGS, NULL},
{ (char *)"new__Matx_double_6_1", _wrap_new__Matx_double_6_1, METH_VARARGS, NULL},
{ (char *)"_Matx_double_6_1___str__", _wrap__Matx_double_6_1___str__, METH_VARARGS, NULL},
{ (char *)"delete__Matx_double_6_1", _wrap_delete__Matx_double_6_1, METH_VARARGS, NULL},
{ (char *)"_Matx_double_6_1_swigregister", _Matx_double_6_1_swigregister, METH_VARARGS, NULL},
{ (char *)"_Vec_double_6_all", _wrap__Vec_double_6_all, METH_VARARGS, NULL},
{ (char *)"_Vec_double_6_mul", _wrap__Vec_double_6_mul, METH_VARARGS, NULL},
{ (char *)"_Vec_double_6___call__", _wrap__Vec_double_6___call__, METH_VARARGS, NULL},
{ (char *)"new__Vec_double_6", _wrap_new__Vec_double_6, METH_VARARGS, NULL},
{ (char *)"_Vec_double_6___str__", _wrap__Vec_double_6___str__, METH_VARARGS, NULL},
{ (char *)"delete__Vec_double_6", _wrap_delete__Vec_double_6, METH_VARARGS, NULL},
{ (char *)"_Vec_double_6_swigregister", _Vec_double_6_swigregister, METH_VARARGS, NULL},
{ (char *)"new__DataType_Vec_double_6", _wrap_new__DataType_Vec_double_6, METH_VARARGS, NULL},
{ (char *)"delete__DataType_Vec_double_6", _wrap_delete__DataType_Vec_double_6, METH_VARARGS, NULL},
{ (char *)"_DataType_Vec_double_6_swigregister", _DataType_Vec_double_6_swigregister, METH_VARARGS, NULL},
{ (char *)"new__mat__np_array_constructor", _wrap_new__mat__np_array_constructor, METH_VARARGS, NULL},
{ (char *)"delete__mat__np_array_constructor", _wrap_delete__mat__np_array_constructor, METH_VARARGS, NULL},
{ (char *)"_mat__np_array_constructor_swigregister", _mat__np_array_constructor_swigregister, METH_VARARGS, NULL},
{ (char *)"_depthToDtype", _wrap__depthToDtype, METH_VARARGS, NULL},
{ (char *)"_toCvType", _wrap__toCvType, METH_VARARGS, NULL},
{ (char *)"delete_Tracker", _wrap_delete_Tracker, METH_VARARGS, NULL},
{ (char *)"Tracker_init", _wrap_Tracker_init, METH_VARARGS, NULL},
{ (char *)"Tracker_update", _wrap_Tracker_update, METH_VARARGS, NULL},
{ (char *)"Tracker_swigregister", Tracker_swigregister, METH_VARARGS, NULL},
{ (char *)"MAX_FILELEN_swigconstant", MAX_FILELEN_swigconstant, METH_VARARGS, NULL},
{ (char *)"sPerfProfileParam_cSrcFile0_set", _wrap_sPerfProfileParam_cSrcFile0_set, METH_VARARGS, NULL},
{ (char *)"sPerfProfileParam_cSrcFile0_get", _wrap_sPerfProfileParam_cSrcFile0_get, METH_VARARGS, NULL},
{ (char *)"sPerfProfileParam_cSrcFile1_set", _wrap_sPerfProfileParam_cSrcFile1_set, METH_VARARGS, NULL},
{ (char *)"sPerfProfileParam_cSrcFile1_get", _wrap_sPerfProfileParam_cSrcFile1_get, METH_VARARGS, NULL},
{ (char *)"sPerfProfileParam_cParamFile_set", _wrap_sPerfProfileParam_cParamFile_set, METH_VARARGS, NULL},
{ (char *)"sPerfProfileParam_cParamFile_get", _wrap_sPerfProfileParam_cParamFile_get, METH_VARARGS, NULL},
{ (char *)"sPerfProfileParam_cOutFileH0_set", _wrap_sPerfProfileParam_cOutFileH0_set, METH_VARARGS, NULL},
{ (char *)"sPerfProfileParam_cOutFileH0_get", _wrap_sPerfProfileParam_cOutFileH0_get, METH_VARARGS, NULL},
{ (char *)"sPerfProfileParam_cOutFileV0_set", _wrap_sPerfProfileParam_cOutFileV0_set, METH_VARARGS, NULL},
{ (char *)"sPerfProfileParam_cOutFileV0_get", _wrap_sPerfProfileParam_cOutFileV0_get, METH_VARARGS, NULL},
{ (char *)"sPerfProfileParam_cOutFileH1_set", _wrap_sPerfProfileParam_cOutFileH1_set, METH_VARARGS, NULL},
{ (char *)"sPerfProfileParam_cOutFileH1_get", _wrap_sPerfProfileParam_cOutFileH1_get, METH_VARARGS, NULL},
{ (char *)"sPerfProfileParam_cOutFileV1_set", _wrap_sPerfProfileParam_cOutFileV1_set, METH_VARARGS, NULL},
{ (char *)"sPerfProfileParam_cOutFileV1_get", _wrap_sPerfProfileParam_cOutFileV1_get, METH_VARARGS, NULL},
{ (char *)"sPerfProfileParam_cOutFileMulSpec_set", _wrap_sPerfProfileParam_cOutFileMulSpec_set, METH_VARARGS, NULL},
{ (char *)"sPerfProfileParam_cOutFileMulSpec_get", _wrap_sPerfProfileParam_cOutFileMulSpec_get, METH_VARARGS, NULL},
{ (char *)"sPerfProfileParam_cOutDFTInvH_set", _wrap_sPerfProfileParam_cOutDFTInvH_set, METH_VARARGS, NULL},
{ (char *)"sPerfProfileParam_cOutDFTInvH_get", _wrap_sPerfProfileParam_cOutDFTInvH_get, METH_VARARGS, NULL},
{ (char *)"sPerfProfileParam_cOutDFTInvV_set", _wrap_sPerfProfileParam_cOutDFTInvV_set, METH_VARARGS, NULL},
{ (char *)"sPerfProfileParam_cOutDFTInvV_get", _wrap_sPerfProfileParam_cOutDFTInvV_get, METH_VARARGS, NULL},
{ (char *)"sPerfProfileParam_cOutImageSum_set", _wrap_sPerfProfileParam_cOutImageSum_set, METH_VARARGS, NULL},
{ (char *)"sPerfProfileParam_cOutImageSum_get", _wrap_sPerfProfileParam_cOutImageSum_get, METH_VARARGS, NULL},
{ (char *)"sPerfProfileParam_cOutSrcImageSum_set", _wrap_sPerfProfileParam_cOutSrcImageSum_set, METH_VARARGS, NULL},
{ (char *)"sPerfProfileParam_cOutSrcImageSum_get", _wrap_sPerfProfileParam_cOutSrcImageSum_get, METH_VARARGS, NULL},
{ (char *)"sPerfProfileParam_cOutFinal_set", _wrap_sPerfProfileParam_cOutFinal_set, METH_VARARGS, NULL},
{ (char *)"sPerfProfileParam_cOutFinal_get", _wrap_sPerfProfileParam_cOutFinal_get, METH_VARARGS, NULL},
{ (char *)"sPerfProfileParam_usInWidth_set", _wrap_sPerfProfileParam_usInWidth_set, METH_VARARGS, NULL},
{ (char *)"sPerfProfileParam_usInWidth_get", _wrap_sPerfProfileParam_usInWidth_get, METH_VARARGS, NULL},
{ (char *)"sPerfProfileParam_usInHeight_set", _wrap_sPerfProfileParam_usInHeight_set, METH_VARARGS, NULL},
{ (char *)"sPerfProfileParam_usInHeight_get", _wrap_sPerfProfileParam_usInHeight_get, METH_VARARGS, NULL},
{ (char *)"sPerfProfileParam_ucInFormat_set", _wrap_sPerfProfileParam_ucInFormat_set, METH_VARARGS, NULL},
{ (char *)"sPerfProfileParam_ucInFormat_get", _wrap_sPerfProfileParam_ucInFormat_get, METH_VARARGS, NULL},
{ (char *)"sPerfProfileParam_usOutWidth_set", _wrap_sPerfProfileParam_usOutWidth_set, METH_VARARGS, NULL},
{ (char *)"sPerfProfileParam_usOutWidth_get", _wrap_sPerfProfileParam_usOutWidth_get, METH_VARARGS, NULL},
{ (char *)"sPerfProfileParam_usOutHeight_set", _wrap_sPerfProfileParam_usOutHeight_set, METH_VARARGS, NULL},
{ (char *)"sPerfProfileParam_usOutHeight_get", _wrap_sPerfProfileParam_usOutHeight_get, METH_VARARGS, NULL},
{ (char *)"sPerfProfileParam_usOutFormat_set", _wrap_sPerfProfileParam_usOutFormat_set, METH_VARARGS, NULL},
{ (char *)"sPerfProfileParam_usOutFormat_get", _wrap_sPerfProfileParam_usOutFormat_get, METH_VARARGS, NULL},
{ (char *)"sPerfProfileParam_usSliceNum_set", _wrap_sPerfProfileParam_usSliceNum_set, METH_VARARGS, NULL},
{ (char *)"sPerfProfileParam_usSliceNum_get", _wrap_sPerfProfileParam_usSliceNum_get, METH_VARARGS, NULL},
{ (char *)"sPerfProfileParam_usSubSliceNum_set", _wrap_sPerfProfileParam_usSubSliceNum_set, METH_VARARGS, NULL},
{ (char *)"sPerfProfileParam_usSubSliceNum_get", _wrap_sPerfProfileParam_usSubSliceNum_get, METH_VARARGS, NULL},
{ (char *)"sPerfProfileParam_usEUNum_set", _wrap_sPerfProfileParam_usEUNum_set, METH_VARARGS, NULL},
{ (char *)"sPerfProfileParam_usEUNum_get", _wrap_sPerfProfileParam_usEUNum_get, METH_VARARGS, NULL},
{ (char *)"sPerfProfileParam_bPrimitive_set", _wrap_sPerfProfileParam_bPrimitive_set, METH_VARARGS, NULL},
{ (char *)"sPerfProfileParam_bPrimitive_get", _wrap_sPerfProfileParam_bPrimitive_get, METH_VARARGS, NULL},
{ (char *)"sPerfProfileParam_usLoops_set", _wrap_sPerfProfileParam_usLoops_set, METH_VARARGS, NULL},
{ (char *)"sPerfProfileParam_usLoops_get", _wrap_sPerfProfileParam_usLoops_get, METH_VARARGS, NULL},
{ (char *)"sPerfProfileParam_usWalkerPattern_set", _wrap_sPerfProfileParam_usWalkerPattern_set, METH_VARARGS, NULL},
{ (char *)"sPerfProfileParam_usWalkerPattern_get", _wrap_sPerfProfileParam_usWalkerPattern_get, METH_VARARGS, NULL},
{ (char *)"sPerfProfileParam_usPitchX_set", _wrap_sPerfProfileParam_usPitchX_set, METH_VARARGS, NULL},
{ (char *)"sPerfProfileParam_usPitchX_get", _wrap_sPerfProfileParam_usPitchX_get, METH_VARARGS, NULL},
{ (char *)"sPerfProfileParam_usPitchY_set", _wrap_sPerfProfileParam_usPitchY_set, METH_VARARGS, NULL},
{ (char *)"sPerfProfileParam_usPitchY_get", _wrap_sPerfProfileParam_usPitchY_get, METH_VARARGS, NULL},
{ (char *)"sPerfProfileParam_usPitchZ_set", _wrap_sPerfProfileParam_usPitchZ_set, METH_VARARGS, NULL},
{ (char *)"sPerfProfileParam_usPitchZ_get", _wrap_sPerfProfileParam_usPitchZ_get, METH_VARARGS, NULL},
{ (char *)"sPerfProfileParam_fScale_set", _wrap_sPerfProfileParam_fScale_set, METH_VARARGS, NULL},
{ (char *)"sPerfProfileParam_fScale_get", _wrap_sPerfProfileParam_fScale_get, METH_VARARGS, NULL},
{ (char *)"sPerfProfileParam_ucChannel_set", _wrap_sPerfProfileParam_ucChannel_set, METH_VARARGS, NULL},
{ (char *)"sPerfProfileParam_ucChannel_get", _wrap_sPerfProfileParam_ucChannel_get, METH_VARARGS, NULL},
{ (char *)"sPerfProfileParam_bInv_set", _wrap_sPerfProfileParam_bInv_set, METH_VARARGS, NULL},
{ (char *)"sPerfProfileParam_bInv_get", _wrap_sPerfProfileParam_bInv_get, METH_VARARGS, NULL},
{ (char *)"new_sPerfProfileParam", _wrap_new_sPerfProfileParam, METH_VARARGS, NULL},
{ (char *)"delete_sPerfProfileParam", _wrap_delete_sPerfProfileParam, METH_VARARGS, NULL},
{ (char *)"sPerfProfileParam_swigregister", sPerfProfileParam_swigregister, METH_VARARGS, NULL},
{ (char *)"InputParamMap_token_set", _wrap_InputParamMap_token_set, METH_VARARGS, NULL},
{ (char *)"InputParamMap_token_get", _wrap_InputParamMap_token_get, METH_VARARGS, NULL},
{ (char *)"InputParamMap_place_set", _wrap_InputParamMap_place_set, METH_VARARGS, NULL},
{ (char *)"InputParamMap_place_get", _wrap_InputParamMap_place_get, METH_VARARGS, NULL},
{ (char *)"InputParamMap_type_set", _wrap_InputParamMap_type_set, METH_VARARGS, NULL},
{ (char *)"InputParamMap_type_get", _wrap_InputParamMap_type_get, METH_VARARGS, NULL},
{ (char *)"InputParamMap_size_set", _wrap_InputParamMap_size_set, METH_VARARGS, NULL},
{ (char *)"InputParamMap_size_get", _wrap_InputParamMap_size_get, METH_VARARGS, NULL},
{ (char *)"new_InputParamMap", _wrap_new_InputParamMap, METH_VARARGS, NULL},
{ (char *)"delete_InputParamMap", _wrap_delete_InputParamMap, METH_VARARGS, NULL},
{ (char *)"InputParamMap_swigregister", InputParamMap_swigregister, METH_VARARGS, NULL},
{ (char *)"new_KCFTracker", _wrap_new_KCFTracker, METH_VARARGS, NULL},
{ (char *)"delete_KCFTracker", _wrap_delete_KCFTracker, METH_VARARGS, NULL},
{ (char *)"KCFTracker_init", _wrap_KCFTracker_init, METH_VARARGS, NULL},
{ (char *)"KCFTracker_update", _wrap_KCFTracker_update, METH_VARARGS, NULL},
{ (char *)"KCFTracker_interp_factor_set", _wrap_KCFTracker_interp_factor_set, METH_VARARGS, NULL},
{ (char *)"KCFTracker_interp_factor_get", _wrap_KCFTracker_interp_factor_get, METH_VARARGS, NULL},
{ (char *)"KCFTracker_sigma_set", _wrap_KCFTracker_sigma_set, METH_VARARGS, NULL},
{ (char *)"KCFTracker_sigma_get", _wrap_KCFTracker_sigma_get, METH_VARARGS, NULL},
{ (char *)"KCFTracker__lambda_set", _wrap_KCFTracker__lambda_set, METH_VARARGS, NULL},
{ (char *)"KCFTracker__lambda_get", _wrap_KCFTracker__lambda_get, METH_VARARGS, NULL},
{ (char *)"KCFTracker_cell_size_set", _wrap_KCFTracker_cell_size_set, METH_VARARGS, NULL},
{ (char *)"KCFTracker_cell_size_get", _wrap_KCFTracker_cell_size_get, METH_VARARGS, NULL},
{ (char *)"KCFTracker_cell_sizeQ_set", _wrap_KCFTracker_cell_sizeQ_set, METH_VARARGS, NULL},
{ (char *)"KCFTracker_cell_sizeQ_get", _wrap_KCFTracker_cell_sizeQ_get, METH_VARARGS, NULL},
{ (char *)"KCFTracker_padding_set", _wrap_KCFTracker_padding_set, METH_VARARGS, NULL},
{ (char *)"KCFTracker_padding_get", _wrap_KCFTracker_padding_get, METH_VARARGS, NULL},
{ (char *)"KCFTracker_output_sigma_factor_set", _wrap_KCFTracker_output_sigma_factor_set, METH_VARARGS, NULL},
{ (char *)"KCFTracker_output_sigma_factor_get", _wrap_KCFTracker_output_sigma_factor_get, METH_VARARGS, NULL},
{ (char *)"KCFTracker_template_size_set", _wrap_KCFTracker_template_size_set, METH_VARARGS, NULL},
{ (char *)"KCFTracker_template_size_get", _wrap_KCFTracker_template_size_get, METH_VARARGS, NULL},
{ (char *)"KCFTracker_pCmDev_get", _wrap_KCFTracker_pCmDev_get, METH_VARARGS, NULL},
{ (char *)"KCFTracker_pCmDev_set", _wrap_KCFTracker_pCmDev_set, METH_VARARGS, NULL},
{ (char *)"KCFTracker_swigregister", KCFTracker_swigregister, METH_VARARGS, NULL},
{ NULL, NULL, 0, NULL }
};
/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
static void *_p_KCFTrackerTo_p_Tracker(void *x, int *SWIGUNUSEDPARM(newmemory)) {
return (void *)((Tracker *) ((KCFTracker *) x));
}
static void *_p_cv__VecT_double_6_tTo_p_cv__MatxT_double_6_1_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
return (void *)((cv::Matx< double,6,1 > *) ((cv::Vec< double,6 > *) x));
}
static void *_p_cv__VecT_double_4_tTo_p_cv__MatxT_double_4_1_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
return (void *)((cv::Matx< double,4,1 > *) ((cv::Vec< double,4 > *) x));
}
static void *_p_cv__VecT_double_3_tTo_p_cv__MatxT_double_3_1_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
return (void *)((cv::Matx< double,3,1 > *) ((cv::Vec< double,3 > *) x));
}
static void *_p_cv__VecT_double_2_tTo_p_cv__MatxT_double_2_1_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
return (void *)((cv::Matx< double,2,1 > *) ((cv::Vec< double,2 > *) x));
}
static void *_p_cv__VecT_int_8_tTo_p_cv__MatxT_int_8_1_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
return (void *)((cv::Matx< int,8,1 > *) ((cv::Vec< int,8 > *) x));
}
static void *_p_cv__VecT_float_6_tTo_p_cv__MatxT_float_6_1_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
return (void *)((cv::Matx< float,6,1 > *) ((cv::Vec< float,6 > *) x));
}
static void *_p_cv__VecT_int_6_tTo_p_cv__MatxT_int_6_1_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
return (void *)((cv::Matx< int,6,1 > *) ((cv::Vec< int,6 > *) x));
}
static void *_p_cv__VecT_float_4_tTo_p_cv__MatxT_float_4_1_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
return (void *)((cv::Matx< float,4,1 > *) ((cv::Vec< float,4 > *) x));
}
static void *_p_cv__VecT_unsigned_char_4_tTo_p_cv__MatxT_unsigned_char_4_1_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
return (void *)((cv::Matx< unsigned char,4,1 > *) ((cv::Vec< unsigned char,4 > *) x));
}
static void *_p_cv__VecT_short_4_tTo_p_cv__MatxT_short_4_1_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
return (void *)((cv::Matx< short,4,1 > *) ((cv::Vec< short,4 > *) x));
}
static void *_p_cv__VecT_ushort_4_tTo_p_cv__MatxT_ushort_4_1_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
return (void *)((cv::Matx< ushort,4,1 > *) ((cv::Vec< ushort,4 > *) x));
}
static void *_p_cv__VecT_int_4_tTo_p_cv__MatxT_int_4_1_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
return (void *)((cv::Matx< int,4,1 > *) ((cv::Vec< int,4 > *) x));
}
static void *_p_cv__VecT_float_3_tTo_p_cv__MatxT_float_3_1_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
return (void *)((cv::Matx< float,3,1 > *) ((cv::Vec< float,3 > *) x));
}
static void *_p_cv__VecT_unsigned_char_3_tTo_p_cv__MatxT_unsigned_char_3_1_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
return (void *)((cv::Matx< unsigned char,3,1 > *) ((cv::Vec< unsigned char,3 > *) x));
}
static void *_p_cv__VecT_short_3_tTo_p_cv__MatxT_short_3_1_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
return (void *)((cv::Matx< short,3,1 > *) ((cv::Vec< short,3 > *) x));
}
static void *_p_cv__VecT_ushort_3_tTo_p_cv__MatxT_ushort_3_1_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
return (void *)((cv::Matx< ushort,3,1 > *) ((cv::Vec< ushort,3 > *) x));
}
static void *_p_cv__VecT_int_3_tTo_p_cv__MatxT_int_3_1_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
return (void *)((cv::Matx< int,3,1 > *) ((cv::Vec< int,3 > *) x));
}
static void *_p_cv__VecT_unsigned_char_2_tTo_p_cv__MatxT_unsigned_char_2_1_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
return (void *)((cv::Matx< unsigned char,2,1 > *) ((cv::Vec< unsigned char,2 > *) x));
}
static void *_p_cv__VecT_float_2_tTo_p_cv__MatxT_float_2_1_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
return (void *)((cv::Matx< float,2,1 > *) ((cv::Vec< float,2 > *) x));
}
static void *_p_cv__VecT_short_2_tTo_p_cv__MatxT_short_2_1_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
return (void *)((cv::Matx< short,2,1 > *) ((cv::Vec< short,2 > *) x));
}
static void *_p_cv__VecT_ushort_2_tTo_p_cv__MatxT_ushort_2_1_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
return (void *)((cv::Matx< ushort,2,1 > *) ((cv::Vec< ushort,2 > *) x));
}
static void *_p_cv__VecT_int_2_tTo_p_cv__MatxT_int_2_1_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
return (void *)((cv::Matx< int,2,1 > *) ((cv::Vec< int,2 > *) x));
}
static swig_type_info _swigt__p_CmDevice = {"_p_CmDevice", "CmDevice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_InputParamMap = {"_p_InputParamMap", "InputParamMap *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_KCFTracker = {"_p_KCFTracker", "KCFTracker *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Tracker = {"_p_Tracker", "Tracker *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__mat__np_array_constructor = {"_p__mat__np_array_constructor", "_mat__np_array_constructor *", 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_channel_type = {"_p_channel_type", "channel_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_cv__DataTypeT_bool_t = {"_p_cv__DataTypeT_bool_t", "cv::DataType< bool > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__DataTypeT_char_t = {"_p_cv__DataTypeT_char_t", "cv::DataType< char > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__DataTypeT_cv__VecT_double_2_t_t = {"_p_cv__DataTypeT_cv__VecT_double_2_t_t", "cv::DataType< cv::Vec< double,2 > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__DataTypeT_cv__VecT_double_3_t_t = {"_p_cv__DataTypeT_cv__VecT_double_3_t_t", "cv::DataType< cv::Vec< double,3 > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__DataTypeT_cv__VecT_double_4_t_t = {"_p_cv__DataTypeT_cv__VecT_double_4_t_t", "cv::DataType< cv::Vec< double,4 > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__DataTypeT_cv__VecT_double_6_t_t = {"_p_cv__DataTypeT_cv__VecT_double_6_t_t", "cv::DataType< cv::Vec< double,6 > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__DataTypeT_cv__VecT_float_2_t_t = {"_p_cv__DataTypeT_cv__VecT_float_2_t_t", "cv::DataType< cv::Vec< float,2 > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__DataTypeT_cv__VecT_float_3_t_t = {"_p_cv__DataTypeT_cv__VecT_float_3_t_t", "cv::DataType< cv::Vec< float,3 > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__DataTypeT_cv__VecT_float_4_t_t = {"_p_cv__DataTypeT_cv__VecT_float_4_t_t", "cv::DataType< cv::Vec< float,4 > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__DataTypeT_cv__VecT_float_6_t_t = {"_p_cv__DataTypeT_cv__VecT_float_6_t_t", "cv::DataType< cv::Vec< float,6 > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__DataTypeT_cv__VecT_int_2_t_t = {"_p_cv__DataTypeT_cv__VecT_int_2_t_t", "cv::DataType< cv::Vec< int,2 > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__DataTypeT_cv__VecT_int_3_t_t = {"_p_cv__DataTypeT_cv__VecT_int_3_t_t", "cv::DataType< cv::Vec< int,3 > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__DataTypeT_cv__VecT_int_4_t_t = {"_p_cv__DataTypeT_cv__VecT_int_4_t_t", "cv::DataType< cv::Vec< int,4 > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__DataTypeT_cv__VecT_int_6_t_t = {"_p_cv__DataTypeT_cv__VecT_int_6_t_t", "cv::DataType< cv::Vec< int,6 > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__DataTypeT_cv__VecT_int_8_t_t = {"_p_cv__DataTypeT_cv__VecT_int_8_t_t", "cv::DataType< cv::Vec< int,8 > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__DataTypeT_cv__VecT_short_2_t_t = {"_p_cv__DataTypeT_cv__VecT_short_2_t_t", "cv::DataType< cv::Vec< short,2 > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__DataTypeT_cv__VecT_short_3_t_t = {"_p_cv__DataTypeT_cv__VecT_short_3_t_t", "cv::DataType< cv::Vec< short,3 > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__DataTypeT_cv__VecT_short_4_t_t = {"_p_cv__DataTypeT_cv__VecT_short_4_t_t", "cv::DataType< cv::Vec< short,4 > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__DataTypeT_cv__VecT_uint8_t_2_t_t = {"_p_cv__DataTypeT_cv__VecT_uint8_t_2_t_t", "cv::DataType< cv::Vec< unsigned char,2 > > *|cv::DataType< cv::Vec< uint8_t,2 > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__DataTypeT_cv__VecT_uint8_t_3_t_t = {"_p_cv__DataTypeT_cv__VecT_uint8_t_3_t_t", "cv::DataType< cv::Vec< unsigned char,3 > > *|cv::DataType< cv::Vec< uint8_t,3 > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__DataTypeT_cv__VecT_uint8_t_4_t_t = {"_p_cv__DataTypeT_cv__VecT_uint8_t_4_t_t", "cv::DataType< cv::Vec< unsigned char,4 > > *|cv::DataType< cv::Vec< uint8_t,4 > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__DataTypeT_cv__VecT_ushort_2_t_t = {"_p_cv__DataTypeT_cv__VecT_ushort_2_t_t", "cv::DataType< cv::Vec< ushort,2 > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__DataTypeT_cv__VecT_ushort_3_t_t = {"_p_cv__DataTypeT_cv__VecT_ushort_3_t_t", "cv::DataType< cv::Vec< ushort,3 > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__DataTypeT_cv__VecT_ushort_4_t_t = {"_p_cv__DataTypeT_cv__VecT_ushort_4_t_t", "cv::DataType< cv::Vec< ushort,4 > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__DataTypeT_double_t = {"_p_cv__DataTypeT_double_t", "cv::DataType< double > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__DataTypeT_float_t = {"_p_cv__DataTypeT_float_t", "cv::DataType< float > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__DataTypeT_int_t = {"_p_cv__DataTypeT_int_t", "cv::DataType< int > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__DataTypeT_schar_t = {"_p_cv__DataTypeT_schar_t", "cv::DataType< schar > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__DataTypeT_short_t = {"_p_cv__DataTypeT_short_t", "cv::DataType< short > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__DataTypeT_uchar_t = {"_p_cv__DataTypeT_uchar_t", "cv::DataType< uchar > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__DataTypeT_ushort_t = {"_p_cv__DataTypeT_ushort_t", "cv::DataType< ushort > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__Mat = {"_p_cv__Mat", "cv::Mat *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__Mat_T_cv__VecT_double_2_t_t = {"_p_cv__Mat_T_cv__VecT_double_2_t_t", "cv::Mat_< cv::Vec< double,2 > > *|cv::Mat2d *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__Mat_T_cv__VecT_double_3_t_t = {"_p_cv__Mat_T_cv__VecT_double_3_t_t", "cv::Mat_< cv::Vec< double,3 > > *|cv::Mat3d *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__Mat_T_cv__VecT_double_4_t_t = {"_p_cv__Mat_T_cv__VecT_double_4_t_t", "cv::Mat_< cv::Vec< double,4 > > *|cv::Mat4d *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__Mat_T_cv__VecT_float_2_t_t = {"_p_cv__Mat_T_cv__VecT_float_2_t_t", "cv::Mat_< cv::Vec< float,2 > > *|cv::Mat2f *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__Mat_T_cv__VecT_float_3_t_t = {"_p_cv__Mat_T_cv__VecT_float_3_t_t", "cv::Mat_< cv::Vec< float,3 > > *|cv::Mat3f *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__Mat_T_cv__VecT_float_4_t_t = {"_p_cv__Mat_T_cv__VecT_float_4_t_t", "cv::Mat_< cv::Vec< float,4 > > *|cv::Mat4f *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__Mat_T_cv__VecT_int_2_t_t = {"_p_cv__Mat_T_cv__VecT_int_2_t_t", "cv::Mat2i *|cv::Mat_< cv::Vec< int,2 > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__Mat_T_cv__VecT_int_3_t_t = {"_p_cv__Mat_T_cv__VecT_int_3_t_t", "cv::Mat_< cv::Vec< int,3 > > *|cv::Mat3i *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__Mat_T_cv__VecT_int_4_t_t = {"_p_cv__Mat_T_cv__VecT_int_4_t_t", "cv::Mat_< cv::Vec< int,4 > > *|cv::Mat4i *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__Mat_T_cv__VecT_short_2_t_t = {"_p_cv__Mat_T_cv__VecT_short_2_t_t", "cv::Mat_< cv::Vec< short,2 > > *|cv::Mat2s *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__Mat_T_cv__VecT_short_3_t_t = {"_p_cv__Mat_T_cv__VecT_short_3_t_t", "cv::Mat_< cv::Vec< short,3 > > *|cv::Mat3s *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__Mat_T_cv__VecT_short_4_t_t = {"_p_cv__Mat_T_cv__VecT_short_4_t_t", "cv::Mat_< cv::Vec< short,4 > > *|cv::Mat4s *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__Mat_T_cv__VecT_uint8_t_2_t_t = {"_p_cv__Mat_T_cv__VecT_uint8_t_2_t_t", "cv::Mat2b *|cv::Mat_< cv::Vec< unsigned char,2 > > *|cv::Mat_< cv::Vec< uint8_t,2 > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__Mat_T_cv__VecT_uint8_t_3_t_t = {"_p_cv__Mat_T_cv__VecT_uint8_t_3_t_t", "cv::Mat_< cv::Vec< unsigned char,3 > > *|cv::Mat_< cv::Vec< uint8_t,3 > > *|cv::Mat3b *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__Mat_T_cv__VecT_uint8_t_4_t_t = {"_p_cv__Mat_T_cv__VecT_uint8_t_4_t_t", "cv::Mat_< cv::Vec< unsigned char,4 > > *|cv::Mat_< cv::Vec< uint8_t,4 > > *|cv::Mat4b *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__Mat_T_cv__VecT_ushort_2_t_t = {"_p_cv__Mat_T_cv__VecT_ushort_2_t_t", "cv::Mat2w *|cv::Mat_< cv::Vec< ushort,2 > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__Mat_T_cv__VecT_ushort_3_t_t = {"_p_cv__Mat_T_cv__VecT_ushort_3_t_t", "cv::Mat_< cv::Vec< ushort,3 > > *|cv::Mat3w *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__Mat_T_cv__VecT_ushort_4_t_t = {"_p_cv__Mat_T_cv__VecT_ushort_4_t_t", "cv::Mat_< cv::Vec< ushort,4 > > *|cv::Mat4w *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__Mat_T_double_t = {"_p_cv__Mat_T_double_t", "cv::Mat1d *|cv::Mat_< double > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__Mat_T_float_t = {"_p_cv__Mat_T_float_t", "cv::Mat1f *|cv::Mat_< float > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__Mat_T_int_t = {"_p_cv__Mat_T_int_t", "cv::Mat_< int > *|cv::Mat1i *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__Mat_T_short_t = {"_p_cv__Mat_T_short_t", "cv::Mat_< short > *|cv::Mat1s *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__Mat_T_uchar_t = {"_p_cv__Mat_T_uchar_t", "cv::Mat_< uchar > *|cv::Mat1b *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__Mat_T_ushort_t = {"_p_cv__Mat_T_ushort_t", "cv::Mat_< ushort > *|cv::Mat1w *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__MatxT_double_1_2_t = {"_p_cv__MatxT_double_1_2_t", "cv::Matx12d *|cv::Matx< double,1,2 > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__MatxT_double_1_3_t = {"_p_cv__MatxT_double_1_3_t", "cv::Matx< double,1,3 > *|cv::Matx13d *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__MatxT_double_1_4_t = {"_p_cv__MatxT_double_1_4_t", "cv::Matx14d *|cv::Matx< double,1,4 > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__MatxT_double_1_6_t = {"_p_cv__MatxT_double_1_6_t", "cv::Matx16d *|cv::Matx< double,1,6 > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__MatxT_double_2_1_t = {"_p_cv__MatxT_double_2_1_t", "cv::Matx< double,2,1 > *|cv::Matx21d *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__MatxT_double_2_2_t = {"_p_cv__MatxT_double_2_2_t", "cv::Matx22d *|cv::Matx< double,2,2 > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__MatxT_double_2_3_t = {"_p_cv__MatxT_double_2_3_t", "cv::Matx< double,2,3 > *|cv::Matx23d *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__MatxT_double_3_1_t = {"_p_cv__MatxT_double_3_1_t", "cv::Matx< double,3,1 > *|cv::Matx31d *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__MatxT_double_3_2_t = {"_p_cv__MatxT_double_3_2_t", "cv::Matx32d *|cv::Matx< double,3,2 > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__MatxT_double_3_3_t = {"_p_cv__MatxT_double_3_3_t", "cv::Matx< double,3,3 > *|cv::Matx33d *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__MatxT_double_3_4_t = {"_p_cv__MatxT_double_3_4_t", "cv::Matx34d *|cv::Matx< double,3,4 > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__MatxT_double_4_1_t = {"_p_cv__MatxT_double_4_1_t", "cv::Matx< double,4,1 > *|cv::Matx41d *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__MatxT_double_4_3_t = {"_p_cv__MatxT_double_4_3_t", "cv::Matx< double,4,3 > *|cv::Matx43d *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__MatxT_double_4_4_t = {"_p_cv__MatxT_double_4_4_t", "cv::Matx44d *|cv::Matx< double,4,4 > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__MatxT_double_6_1_t = {"_p_cv__MatxT_double_6_1_t", "cv::Matx< double,6,1 > *|cv::Matx61d *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__MatxT_double_6_6_t = {"_p_cv__MatxT_double_6_6_t", "cv::Matx< double,6,6 > *|cv::Matx66d *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__MatxT_float_1_2_t = {"_p_cv__MatxT_float_1_2_t", "cv::Matx< float,1,2 > *|cv::Matx12f *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__MatxT_float_1_3_t = {"_p_cv__MatxT_float_1_3_t", "cv::Matx< float,1,3 > *|cv::Matx13f *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__MatxT_float_1_4_t = {"_p_cv__MatxT_float_1_4_t", "cv::Matx< float,1,4 > *|cv::Matx14f *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__MatxT_float_1_6_t = {"_p_cv__MatxT_float_1_6_t", "cv::Matx16f *|cv::Matx< float,1,6 > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__MatxT_float_2_1_t = {"_p_cv__MatxT_float_2_1_t", "cv::Matx21f *|cv::Matx< float,2,1 > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__MatxT_float_2_2_t = {"_p_cv__MatxT_float_2_2_t", "cv::Matx22f *|cv::Matx< float,2,2 > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__MatxT_float_2_3_t = {"_p_cv__MatxT_float_2_3_t", "cv::Matx< float,2,3 > *|cv::Matx23f *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__MatxT_float_3_1_t = {"_p_cv__MatxT_float_3_1_t", "cv::Matx< float,3,1 > *|cv::Matx31f *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__MatxT_float_3_2_t = {"_p_cv__MatxT_float_3_2_t", "cv::Matx< float,3,2 > *|cv::Matx32f *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__MatxT_float_3_3_t = {"_p_cv__MatxT_float_3_3_t", "cv::Matx< float,3,3 > *|cv::Matx33f *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__MatxT_float_3_4_t = {"_p_cv__MatxT_float_3_4_t", "cv::Matx34f *|cv::Matx< float,3,4 > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__MatxT_float_4_1_t = {"_p_cv__MatxT_float_4_1_t", "cv::Matx< float,4,1 > *|cv::Matx41f *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__MatxT_float_4_3_t = {"_p_cv__MatxT_float_4_3_t", "cv::Matx< float,4,3 > *|cv::Matx43f *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__MatxT_float_4_4_t = {"_p_cv__MatxT_float_4_4_t", "cv::Matx44f *|cv::Matx< float,4,4 > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__MatxT_float_6_1_t = {"_p_cv__MatxT_float_6_1_t", "cv::Matx< float,6,1 > *|cv::Matx61f *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__MatxT_float_6_6_t = {"_p_cv__MatxT_float_6_6_t", "cv::Matx< float,6,6 > *|cv::Matx66f *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__MatxT_int_1_2_t = {"_p_cv__MatxT_int_1_2_t", "cv::Matx< int,1,2 > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__MatxT_int_1_3_t = {"_p_cv__MatxT_int_1_3_t", "cv::Matx< int,1,3 > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__MatxT_int_1_4_t = {"_p_cv__MatxT_int_1_4_t", "cv::Matx< int,1,4 > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__MatxT_int_1_6_t = {"_p_cv__MatxT_int_1_6_t", "cv::Matx< int,1,6 > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__MatxT_int_1_8_t = {"_p_cv__MatxT_int_1_8_t", "cv::Matx< int,1,8 > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__MatxT_int_2_1_t = {"_p_cv__MatxT_int_2_1_t", "cv::Matx< int,2,1 > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__MatxT_int_3_1_t = {"_p_cv__MatxT_int_3_1_t", "cv::Matx< int,3,1 > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__MatxT_int_4_1_t = {"_p_cv__MatxT_int_4_1_t", "cv::Matx< int,4,1 > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__MatxT_int_6_1_t = {"_p_cv__MatxT_int_6_1_t", "cv::Matx< int,6,1 > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__MatxT_int_8_1_t = {"_p_cv__MatxT_int_8_1_t", "cv::Matx< int,8,1 > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__MatxT_short_1_2_t = {"_p_cv__MatxT_short_1_2_t", "cv::Matx< short,1,2 > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__MatxT_short_1_3_t = {"_p_cv__MatxT_short_1_3_t", "cv::Matx< short,1,3 > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__MatxT_short_1_4_t = {"_p_cv__MatxT_short_1_4_t", "cv::Matx< short,1,4 > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__MatxT_short_2_1_t = {"_p_cv__MatxT_short_2_1_t", "cv::Matx< short,2,1 > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__MatxT_short_3_1_t = {"_p_cv__MatxT_short_3_1_t", "cv::Matx< short,3,1 > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__MatxT_short_4_1_t = {"_p_cv__MatxT_short_4_1_t", "cv::Matx< short,4,1 > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__MatxT_unsigned_char_1_2_t = {"_p_cv__MatxT_unsigned_char_1_2_t", "cv::Matx< unsigned char,1,2 > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__MatxT_unsigned_char_1_3_t = {"_p_cv__MatxT_unsigned_char_1_3_t", "cv::Matx< unsigned char,1,3 > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__MatxT_unsigned_char_1_4_t = {"_p_cv__MatxT_unsigned_char_1_4_t", "cv::Matx< unsigned char,1,4 > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__MatxT_unsigned_char_2_1_t = {"_p_cv__MatxT_unsigned_char_2_1_t", "cv::Matx< unsigned char,2,1 > *|cv::Matx< uint8_t,2,1 > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__MatxT_unsigned_char_3_1_t = {"_p_cv__MatxT_unsigned_char_3_1_t", "cv::Matx< unsigned char,3,1 > *|cv::Matx< uint8_t,3,1 > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__MatxT_unsigned_char_4_1_t = {"_p_cv__MatxT_unsigned_char_4_1_t", "cv::Matx< unsigned char,4,1 > *|cv::Matx< uint8_t,4,1 > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__MatxT_ushort_1_2_t = {"_p_cv__MatxT_ushort_1_2_t", "cv::Matx< ushort,1,2 > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__MatxT_ushort_1_3_t = {"_p_cv__MatxT_ushort_1_3_t", "cv::Matx< ushort,1,3 > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__MatxT_ushort_1_4_t = {"_p_cv__MatxT_ushort_1_4_t", "cv::Matx< ushort,1,4 > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__MatxT_ushort_2_1_t = {"_p_cv__MatxT_ushort_2_1_t", "cv::Matx< ushort,2,1 > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__MatxT_ushort_3_1_t = {"_p_cv__MatxT_ushort_3_1_t", "cv::Matx< ushort,3,1 > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__MatxT_ushort_4_1_t = {"_p_cv__MatxT_ushort_4_1_t", "cv::Matx< ushort,4,1 > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__Matx_AddOp = {"_p_cv__Matx_AddOp", "cv::Matx_AddOp *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__Matx_DivOp = {"_p_cv__Matx_DivOp", "cv::Matx_DivOp *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__Matx_MatMulOp = {"_p_cv__Matx_MatMulOp", "cv::Matx_MatMulOp *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__Matx_MulOp = {"_p_cv__Matx_MulOp", "cv::Matx_MulOp *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__Matx_ScaleOp = {"_p_cv__Matx_ScaleOp", "cv::Matx_ScaleOp *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__Matx_SubOp = {"_p_cv__Matx_SubOp", "cv::Matx_SubOp *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__Matx_TOp = {"_p_cv__Matx_TOp", "cv::Matx_TOp *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__Point_T_double_t = {"_p_cv__Point_T_double_t", "cv::Point2d *|cv::Point_< double > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__Point_T_float_t = {"_p_cv__Point_T_float_t", "cv::Point_< float > *|cv::Point2f *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__Point_T_int_t = {"_p_cv__Point_T_int_t", "cv::Point *|cv::Point2i *|cv::Point_< int > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__Range = {"_p_cv__Range", "cv::Range *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__Rect_T_double_t = {"_p_cv__Rect_T_double_t", "cv::Rect2d *|cv::Rect_< double > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__Rect_T_float_t = {"_p_cv__Rect_T_float_t", "cv::Rect_< float > *|cv::Rect2f *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__Rect_T_int_t = {"_p_cv__Rect_T_int_t", "cv::Rect *|cv::Rect2i *|cv::Rect_< int > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__Scalar_T_double_t = {"_p_cv__Scalar_T_double_t", "cv::Scalar *|cv::Scalar_< double > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__Size_T_double_t = {"_p_cv__Size_T_double_t", "cv::Size2d *|cv::Size_< double > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__Size_T_float_t = {"_p_cv__Size_T_float_t", "cv::Size_< float > *|cv::Size2f *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__Size_T_int_t = {"_p_cv__Size_T_int_t", "cv::Size *|cv::Size2i *|cv::Size_< int > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__VecT_double_2_t = {"_p_cv__VecT_double_2_t", "cv::Vec2d *|cv::Vec< double,2 > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__VecT_double_3_t = {"_p_cv__VecT_double_3_t", "cv::Vec< double,3 > *|cv::Vec3d *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__VecT_double_4_t = {"_p_cv__VecT_double_4_t", "cv::Vec4d *|cv::Vec< double,4 > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__VecT_double_6_t = {"_p_cv__VecT_double_6_t", "cv::Vec6d *|cv::Vec< double,6 > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__VecT_float_2_t = {"_p_cv__VecT_float_2_t", "cv::Vec< float,2 > *|cv::Vec2f *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__VecT_float_3_t = {"_p_cv__VecT_float_3_t", "cv::Vec< float,3 > *|cv::Vec3f *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__VecT_float_4_t = {"_p_cv__VecT_float_4_t", "cv::Vec4f *|cv::Vec< float,4 > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__VecT_float_6_t = {"_p_cv__VecT_float_6_t", "cv::Vec< float,6 > *|cv::Vec6f *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__VecT_int_2_t = {"_p_cv__VecT_int_2_t", "cv::Vec2i *|cv::Vec< int,2 > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__VecT_int_3_t = {"_p_cv__VecT_int_3_t", "cv::Vec< int,3 > *|cv::Vec3i *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__VecT_int_4_t = {"_p_cv__VecT_int_4_t", "cv::Vec< int,4 > *|cv::Vec4i *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__VecT_int_6_t = {"_p_cv__VecT_int_6_t", "cv::Vec< int,6 > *|cv::Vec6i *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__VecT_int_8_t = {"_p_cv__VecT_int_8_t", "cv::Vec< int,8 > *|cv::Vec8i *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__VecT_short_2_t = {"_p_cv__VecT_short_2_t", "cv::Vec2s *|cv::Vec< short,2 > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__VecT_short_3_t = {"_p_cv__VecT_short_3_t", "cv::Vec< short,3 > *|cv::Vec3s *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__VecT_short_4_t = {"_p_cv__VecT_short_4_t", "cv::Vec4s *|cv::Vec< short,4 > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__VecT_unsigned_char_2_t = {"_p_cv__VecT_unsigned_char_2_t", "cv::Vec2b *|cv::Vec< unsigned char,2 > *|cv::Vec< uint8_t,2 > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__VecT_unsigned_char_3_t = {"_p_cv__VecT_unsigned_char_3_t", "cv::Vec< unsigned char,3 > *|cv::Vec< uint8_t,3 > *|cv::Vec3b *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__VecT_unsigned_char_4_t = {"_p_cv__VecT_unsigned_char_4_t", "cv::Vec< unsigned char,4 > *|cv::Vec4b *|cv::Vec< uint8_t,4 > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__VecT_ushort_2_t = {"_p_cv__VecT_ushort_2_t", "cv::Vec2w *|cv::Vec< ushort,2 > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__VecT_ushort_3_t = {"_p_cv__VecT_ushort_3_t", "cv::Vec< ushort,3 > *|cv::Vec3w *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv__VecT_ushort_4_t = {"_p_cv__VecT_ushort_4_t", "cv::Vec< ushort,4 > *|cv::Vec4w *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv___SizeOfT_double_t = {"_p_cv___SizeOfT_double_t", "cv::_SizeOf< double > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv___SizeOfT_float_t = {"_p_cv___SizeOfT_float_t", "cv::_SizeOf< float > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv___SizeOfT_int_t = {"_p_cv___SizeOfT_int_t", "cv::_SizeOf< int > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv___SizeOfT_short_t = {"_p_cv___SizeOfT_short_t", "cv::_SizeOf< short > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv___SizeOfT_unsigned_char_t = {"_p_cv___SizeOfT_unsigned_char_t", "cv::_SizeOf< unsigned char > *|cv::_SizeOf< uint8_t > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cv___SizeOfT_ushort_t = {"_p_cv___SizeOfT_ushort_t", "cv::_SizeOf< ushort > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_diag_type = {"_p_diag_type", "diag_type *", 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_float = {"_p_float", "float *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_int = {"_p_int", "intptr_t *|int *|int_least32_t *|int_fast32_t *|int32_t *|int_fast16_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_long_long = {"_p_long_long", "int_least64_t *|int_fast64_t *|int64_t *|long long *|intmax_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mat_type = {"_p_mat_type", "mat_type *", 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_sPerfProfileParam = {"_p_sPerfProfileParam", "sPerfProfileParam *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_short = {"_p_short", "short *|int_least16_t *|int16_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_signed_char = {"_p_signed_char", "signed char *|int_least8_t *|int_fast8_t *|int8_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_size_t = {"_p_size_t", "size_t *", 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__allocatorT_double_t = {"_p_std__allocatorT_double_t", "std::vector< double >::allocator_type *|std::allocator< double > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_float_t = {"_p_std__allocatorT_float_t", "std::vector< float >::allocator_type *|std::allocator< float > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_int_t = {"_p_std__allocatorT_int_t", "std::vector< int >::allocator_type *|std::allocator< int > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_short_t = {"_p_std__allocatorT_short_t", "std::allocator< short > *|std::vector< short >::allocator_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_unsigned_char_t = {"_p_std__allocatorT_unsigned_char_t", "std::vector< unsigned char >::allocator_type *|std::allocator< unsigned char > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_ushort_t = {"_p_std__allocatorT_ushort_t", "std::allocator< ushort > *|std::vector< ushort >::allocator_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_double_std__allocatorT_double_t_t = {"_p_std__vectorT_double_std__allocatorT_double_t_t", "std::vector< double,std::allocator< double > > *|std::vector< double > *", 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_int_std__allocatorT_int_t_t = {"_p_std__vectorT_int_std__allocatorT_int_t_t", "std::vector< int,std::allocator< int > > *|std::vector< int > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_short_std__allocatorT_short_t_t = {"_p_std__vectorT_short_std__allocatorT_short_t_t", "std::vector< short > *|std::vector< short,std::allocator< short > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t = {"_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t", "std::vector< unsigned char > *|std::vector< unsigned char,std::allocator< unsigned char > > *|std::vector< uint8_t > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_ushort_std__allocatorT_ushort_t_t = {"_p_std__vectorT_ushort_std__allocatorT_ushort_t_t", "std::vector< ushort > *|std::vector< ushort,std::allocator< ushort > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_swig__SwigPyIterator = {"_p_swig__SwigPyIterator", "swig::SwigPyIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_uchar = {"_p_uchar", "uchar *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|uint_least8_t *|uint_fast8_t *|uint8_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "uintptr_t *|uint_least32_t *|uint_fast32_t *|uint32_t *|unsigned int *|uint_fast16_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_unsigned_long_long = {"_p_unsigned_long_long", "uint_least64_t *|uint_fast64_t *|uint64_t *|unsigned long long *|uintmax_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_unsigned_short = {"_p_unsigned_short", "unsigned short *|uint_least16_t *|uint16_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ushort = {"_p_ushort", "std::vector< ushort >::value_type *|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_vec_type = {"_p_vec_type", "vec_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_work_type = {"_p_work_type", "work_type *", 0, 0, (void*)0, 0};
static swig_type_info *swig_type_initial[] = {
&_swigt__p_CmDevice,
&_swigt__p_InputParamMap,
&_swigt__p_KCFTracker,
&_swigt__p_Tracker,
&_swigt__p__mat__np_array_constructor,
&_swigt__p_allocator_type,
&_swigt__p_channel_type,
&_swigt__p_char,
&_swigt__p_cv__DataTypeT_bool_t,
&_swigt__p_cv__DataTypeT_char_t,
&_swigt__p_cv__DataTypeT_cv__VecT_double_2_t_t,
&_swigt__p_cv__DataTypeT_cv__VecT_double_3_t_t,
&_swigt__p_cv__DataTypeT_cv__VecT_double_4_t_t,
&_swigt__p_cv__DataTypeT_cv__VecT_double_6_t_t,
&_swigt__p_cv__DataTypeT_cv__VecT_float_2_t_t,
&_swigt__p_cv__DataTypeT_cv__VecT_float_3_t_t,
&_swigt__p_cv__DataTypeT_cv__VecT_float_4_t_t,
&_swigt__p_cv__DataTypeT_cv__VecT_float_6_t_t,
&_swigt__p_cv__DataTypeT_cv__VecT_int_2_t_t,
&_swigt__p_cv__DataTypeT_cv__VecT_int_3_t_t,
&_swigt__p_cv__DataTypeT_cv__VecT_int_4_t_t,
&_swigt__p_cv__DataTypeT_cv__VecT_int_6_t_t,
&_swigt__p_cv__DataTypeT_cv__VecT_int_8_t_t,
&_swigt__p_cv__DataTypeT_cv__VecT_short_2_t_t,
&_swigt__p_cv__DataTypeT_cv__VecT_short_3_t_t,
&_swigt__p_cv__DataTypeT_cv__VecT_short_4_t_t,
&_swigt__p_cv__DataTypeT_cv__VecT_uint8_t_2_t_t,
&_swigt__p_cv__DataTypeT_cv__VecT_uint8_t_3_t_t,
&_swigt__p_cv__DataTypeT_cv__VecT_uint8_t_4_t_t,
&_swigt__p_cv__DataTypeT_cv__VecT_ushort_2_t_t,
&_swigt__p_cv__DataTypeT_cv__VecT_ushort_3_t_t,
&_swigt__p_cv__DataTypeT_cv__VecT_ushort_4_t_t,
&_swigt__p_cv__DataTypeT_double_t,
&_swigt__p_cv__DataTypeT_float_t,
&_swigt__p_cv__DataTypeT_int_t,
&_swigt__p_cv__DataTypeT_schar_t,
&_swigt__p_cv__DataTypeT_short_t,
&_swigt__p_cv__DataTypeT_uchar_t,
&_swigt__p_cv__DataTypeT_ushort_t,
&_swigt__p_cv__Mat,
&_swigt__p_cv__Mat_T_cv__VecT_double_2_t_t,
&_swigt__p_cv__Mat_T_cv__VecT_double_3_t_t,
&_swigt__p_cv__Mat_T_cv__VecT_double_4_t_t,
&_swigt__p_cv__Mat_T_cv__VecT_float_2_t_t,
&_swigt__p_cv__Mat_T_cv__VecT_float_3_t_t,
&_swigt__p_cv__Mat_T_cv__VecT_float_4_t_t,
&_swigt__p_cv__Mat_T_cv__VecT_int_2_t_t,
&_swigt__p_cv__Mat_T_cv__VecT_int_3_t_t,
&_swigt__p_cv__Mat_T_cv__VecT_int_4_t_t,
&_swigt__p_cv__Mat_T_cv__VecT_short_2_t_t,
&_swigt__p_cv__Mat_T_cv__VecT_short_3_t_t,
&_swigt__p_cv__Mat_T_cv__VecT_short_4_t_t,
&_swigt__p_cv__Mat_T_cv__VecT_uint8_t_2_t_t,
&_swigt__p_cv__Mat_T_cv__VecT_uint8_t_3_t_t,
&_swigt__p_cv__Mat_T_cv__VecT_uint8_t_4_t_t,
&_swigt__p_cv__Mat_T_cv__VecT_ushort_2_t_t,
&_swigt__p_cv__Mat_T_cv__VecT_ushort_3_t_t,
&_swigt__p_cv__Mat_T_cv__VecT_ushort_4_t_t,
&_swigt__p_cv__Mat_T_double_t,
&_swigt__p_cv__Mat_T_float_t,
&_swigt__p_cv__Mat_T_int_t,
&_swigt__p_cv__Mat_T_short_t,
&_swigt__p_cv__Mat_T_uchar_t,
&_swigt__p_cv__Mat_T_ushort_t,
&_swigt__p_cv__MatxT_double_1_2_t,
&_swigt__p_cv__MatxT_double_1_3_t,
&_swigt__p_cv__MatxT_double_1_4_t,
&_swigt__p_cv__MatxT_double_1_6_t,
&_swigt__p_cv__MatxT_double_2_1_t,
&_swigt__p_cv__MatxT_double_2_2_t,
&_swigt__p_cv__MatxT_double_2_3_t,
&_swigt__p_cv__MatxT_double_3_1_t,
&_swigt__p_cv__MatxT_double_3_2_t,
&_swigt__p_cv__MatxT_double_3_3_t,
&_swigt__p_cv__MatxT_double_3_4_t,
&_swigt__p_cv__MatxT_double_4_1_t,
&_swigt__p_cv__MatxT_double_4_3_t,
&_swigt__p_cv__MatxT_double_4_4_t,
&_swigt__p_cv__MatxT_double_6_1_t,
&_swigt__p_cv__MatxT_double_6_6_t,
&_swigt__p_cv__MatxT_float_1_2_t,
&_swigt__p_cv__MatxT_float_1_3_t,
&_swigt__p_cv__MatxT_float_1_4_t,
&_swigt__p_cv__MatxT_float_1_6_t,
&_swigt__p_cv__MatxT_float_2_1_t,
&_swigt__p_cv__MatxT_float_2_2_t,
&_swigt__p_cv__MatxT_float_2_3_t,
&_swigt__p_cv__MatxT_float_3_1_t,
&_swigt__p_cv__MatxT_float_3_2_t,
&_swigt__p_cv__MatxT_float_3_3_t,
&_swigt__p_cv__MatxT_float_3_4_t,
&_swigt__p_cv__MatxT_float_4_1_t,
&_swigt__p_cv__MatxT_float_4_3_t,
&_swigt__p_cv__MatxT_float_4_4_t,
&_swigt__p_cv__MatxT_float_6_1_t,
&_swigt__p_cv__MatxT_float_6_6_t,
&_swigt__p_cv__MatxT_int_1_2_t,
&_swigt__p_cv__MatxT_int_1_3_t,
&_swigt__p_cv__MatxT_int_1_4_t,
&_swigt__p_cv__MatxT_int_1_6_t,
&_swigt__p_cv__MatxT_int_1_8_t,
&_swigt__p_cv__MatxT_int_2_1_t,
&_swigt__p_cv__MatxT_int_3_1_t,
&_swigt__p_cv__MatxT_int_4_1_t,
&_swigt__p_cv__MatxT_int_6_1_t,
&_swigt__p_cv__MatxT_int_8_1_t,
&_swigt__p_cv__MatxT_short_1_2_t,
&_swigt__p_cv__MatxT_short_1_3_t,
&_swigt__p_cv__MatxT_short_1_4_t,
&_swigt__p_cv__MatxT_short_2_1_t,
&_swigt__p_cv__MatxT_short_3_1_t,
&_swigt__p_cv__MatxT_short_4_1_t,
&_swigt__p_cv__MatxT_unsigned_char_1_2_t,
&_swigt__p_cv__MatxT_unsigned_char_1_3_t,
&_swigt__p_cv__MatxT_unsigned_char_1_4_t,
&_swigt__p_cv__MatxT_unsigned_char_2_1_t,
&_swigt__p_cv__MatxT_unsigned_char_3_1_t,
&_swigt__p_cv__MatxT_unsigned_char_4_1_t,
&_swigt__p_cv__MatxT_ushort_1_2_t,
&_swigt__p_cv__MatxT_ushort_1_3_t,
&_swigt__p_cv__MatxT_ushort_1_4_t,
&_swigt__p_cv__MatxT_ushort_2_1_t,
&_swigt__p_cv__MatxT_ushort_3_1_t,
&_swigt__p_cv__MatxT_ushort_4_1_t,
&_swigt__p_cv__Matx_AddOp,
&_swigt__p_cv__Matx_DivOp,
&_swigt__p_cv__Matx_MatMulOp,
&_swigt__p_cv__Matx_MulOp,
&_swigt__p_cv__Matx_ScaleOp,
&_swigt__p_cv__Matx_SubOp,
&_swigt__p_cv__Matx_TOp,
&_swigt__p_cv__Point_T_double_t,
&_swigt__p_cv__Point_T_float_t,
&_swigt__p_cv__Point_T_int_t,
&_swigt__p_cv__Range,
&_swigt__p_cv__Rect_T_double_t,
&_swigt__p_cv__Rect_T_float_t,
&_swigt__p_cv__Rect_T_int_t,
&_swigt__p_cv__Scalar_T_double_t,
&_swigt__p_cv__Size_T_double_t,
&_swigt__p_cv__Size_T_float_t,
&_swigt__p_cv__Size_T_int_t,
&_swigt__p_cv__VecT_double_2_t,
&_swigt__p_cv__VecT_double_3_t,
&_swigt__p_cv__VecT_double_4_t,
&_swigt__p_cv__VecT_double_6_t,
&_swigt__p_cv__VecT_float_2_t,
&_swigt__p_cv__VecT_float_3_t,
&_swigt__p_cv__VecT_float_4_t,
&_swigt__p_cv__VecT_float_6_t,
&_swigt__p_cv__VecT_int_2_t,
&_swigt__p_cv__VecT_int_3_t,
&_swigt__p_cv__VecT_int_4_t,
&_swigt__p_cv__VecT_int_6_t,
&_swigt__p_cv__VecT_int_8_t,
&_swigt__p_cv__VecT_short_2_t,
&_swigt__p_cv__VecT_short_3_t,
&_swigt__p_cv__VecT_short_4_t,
&_swigt__p_cv__VecT_unsigned_char_2_t,
&_swigt__p_cv__VecT_unsigned_char_3_t,
&_swigt__p_cv__VecT_unsigned_char_4_t,
&_swigt__p_cv__VecT_ushort_2_t,
&_swigt__p_cv__VecT_ushort_3_t,
&_swigt__p_cv__VecT_ushort_4_t,
&_swigt__p_cv___SizeOfT_double_t,
&_swigt__p_cv___SizeOfT_float_t,
&_swigt__p_cv___SizeOfT_int_t,
&_swigt__p_cv___SizeOfT_short_t,
&_swigt__p_cv___SizeOfT_unsigned_char_t,
&_swigt__p_cv___SizeOfT_ushort_t,
&_swigt__p_diag_type,
&_swigt__p_difference_type,
&_swigt__p_double,
&_swigt__p_float,
&_swigt__p_int,
&_swigt__p_long_long,
&_swigt__p_mat_type,
&_swigt__p_p_PyObject,
&_swigt__p_sPerfProfileParam,
&_swigt__p_short,
&_swigt__p_signed_char,
&_swigt__p_size_t,
&_swigt__p_size_type,
&_swigt__p_std__allocatorT_double_t,
&_swigt__p_std__allocatorT_float_t,
&_swigt__p_std__allocatorT_int_t,
&_swigt__p_std__allocatorT_short_t,
&_swigt__p_std__allocatorT_unsigned_char_t,
&_swigt__p_std__allocatorT_ushort_t,
&_swigt__p_std__invalid_argument,
&_swigt__p_std__vectorT_double_std__allocatorT_double_t_t,
&_swigt__p_std__vectorT_float_std__allocatorT_float_t_t,
&_swigt__p_std__vectorT_int_std__allocatorT_int_t_t,
&_swigt__p_std__vectorT_short_std__allocatorT_short_t_t,
&_swigt__p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t,
&_swigt__p_std__vectorT_ushort_std__allocatorT_ushort_t_t,
&_swigt__p_swig__SwigPyIterator,
&_swigt__p_uchar,
&_swigt__p_unsigned_char,
&_swigt__p_unsigned_int,
&_swigt__p_unsigned_long_long,
&_swigt__p_unsigned_short,
&_swigt__p_ushort,
&_swigt__p_value_type,
&_swigt__p_vec_type,
&_swigt__p_void,
&_swigt__p_work_type,
};
static swig_cast_info _swigc__p_CmDevice[] = { {&_swigt__p_CmDevice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_InputParamMap[] = { {&_swigt__p_InputParamMap, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_KCFTracker[] = { {&_swigt__p_KCFTracker, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Tracker[] = { {&_swigt__p_Tracker, 0, 0, 0}, {&_swigt__p_KCFTracker, _p_KCFTrackerTo_p_Tracker, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__mat__np_array_constructor[] = { {&_swigt__p__mat__np_array_constructor, 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_channel_type[] = { {&_swigt__p_channel_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_cv__DataTypeT_bool_t[] = { {&_swigt__p_cv__DataTypeT_bool_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__DataTypeT_char_t[] = { {&_swigt__p_cv__DataTypeT_char_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__DataTypeT_cv__VecT_double_2_t_t[] = { {&_swigt__p_cv__DataTypeT_cv__VecT_double_2_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__DataTypeT_cv__VecT_double_3_t_t[] = { {&_swigt__p_cv__DataTypeT_cv__VecT_double_3_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__DataTypeT_cv__VecT_double_4_t_t[] = { {&_swigt__p_cv__DataTypeT_cv__VecT_double_4_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__DataTypeT_cv__VecT_double_6_t_t[] = { {&_swigt__p_cv__DataTypeT_cv__VecT_double_6_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__DataTypeT_cv__VecT_float_2_t_t[] = { {&_swigt__p_cv__DataTypeT_cv__VecT_float_2_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__DataTypeT_cv__VecT_float_3_t_t[] = { {&_swigt__p_cv__DataTypeT_cv__VecT_float_3_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__DataTypeT_cv__VecT_float_4_t_t[] = { {&_swigt__p_cv__DataTypeT_cv__VecT_float_4_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__DataTypeT_cv__VecT_float_6_t_t[] = { {&_swigt__p_cv__DataTypeT_cv__VecT_float_6_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__DataTypeT_cv__VecT_int_2_t_t[] = { {&_swigt__p_cv__DataTypeT_cv__VecT_int_2_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__DataTypeT_cv__VecT_int_3_t_t[] = { {&_swigt__p_cv__DataTypeT_cv__VecT_int_3_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__DataTypeT_cv__VecT_int_4_t_t[] = { {&_swigt__p_cv__DataTypeT_cv__VecT_int_4_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__DataTypeT_cv__VecT_int_6_t_t[] = { {&_swigt__p_cv__DataTypeT_cv__VecT_int_6_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__DataTypeT_cv__VecT_int_8_t_t[] = { {&_swigt__p_cv__DataTypeT_cv__VecT_int_8_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__DataTypeT_cv__VecT_short_2_t_t[] = { {&_swigt__p_cv__DataTypeT_cv__VecT_short_2_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__DataTypeT_cv__VecT_short_3_t_t[] = { {&_swigt__p_cv__DataTypeT_cv__VecT_short_3_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__DataTypeT_cv__VecT_short_4_t_t[] = { {&_swigt__p_cv__DataTypeT_cv__VecT_short_4_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__DataTypeT_cv__VecT_uint8_t_2_t_t[] = { {&_swigt__p_cv__DataTypeT_cv__VecT_uint8_t_2_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__DataTypeT_cv__VecT_uint8_t_3_t_t[] = { {&_swigt__p_cv__DataTypeT_cv__VecT_uint8_t_3_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__DataTypeT_cv__VecT_uint8_t_4_t_t[] = { {&_swigt__p_cv__DataTypeT_cv__VecT_uint8_t_4_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__DataTypeT_cv__VecT_ushort_2_t_t[] = { {&_swigt__p_cv__DataTypeT_cv__VecT_ushort_2_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__DataTypeT_cv__VecT_ushort_3_t_t[] = { {&_swigt__p_cv__DataTypeT_cv__VecT_ushort_3_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__DataTypeT_cv__VecT_ushort_4_t_t[] = { {&_swigt__p_cv__DataTypeT_cv__VecT_ushort_4_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__DataTypeT_double_t[] = { {&_swigt__p_cv__DataTypeT_double_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__DataTypeT_float_t[] = { {&_swigt__p_cv__DataTypeT_float_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__DataTypeT_int_t[] = { {&_swigt__p_cv__DataTypeT_int_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__DataTypeT_schar_t[] = { {&_swigt__p_cv__DataTypeT_schar_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__DataTypeT_short_t[] = { {&_swigt__p_cv__DataTypeT_short_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__DataTypeT_uchar_t[] = { {&_swigt__p_cv__DataTypeT_uchar_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__DataTypeT_ushort_t[] = { {&_swigt__p_cv__DataTypeT_ushort_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__Mat[] = { {&_swigt__p_cv__Mat, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__Mat_T_cv__VecT_double_2_t_t[] = { {&_swigt__p_cv__Mat_T_cv__VecT_double_2_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__Mat_T_cv__VecT_double_3_t_t[] = { {&_swigt__p_cv__Mat_T_cv__VecT_double_3_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__Mat_T_cv__VecT_double_4_t_t[] = { {&_swigt__p_cv__Mat_T_cv__VecT_double_4_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__Mat_T_cv__VecT_float_2_t_t[] = { {&_swigt__p_cv__Mat_T_cv__VecT_float_2_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__Mat_T_cv__VecT_float_3_t_t[] = { {&_swigt__p_cv__Mat_T_cv__VecT_float_3_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__Mat_T_cv__VecT_float_4_t_t[] = { {&_swigt__p_cv__Mat_T_cv__VecT_float_4_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__Mat_T_cv__VecT_int_2_t_t[] = { {&_swigt__p_cv__Mat_T_cv__VecT_int_2_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__Mat_T_cv__VecT_int_3_t_t[] = { {&_swigt__p_cv__Mat_T_cv__VecT_int_3_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__Mat_T_cv__VecT_int_4_t_t[] = { {&_swigt__p_cv__Mat_T_cv__VecT_int_4_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__Mat_T_cv__VecT_short_2_t_t[] = { {&_swigt__p_cv__Mat_T_cv__VecT_short_2_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__Mat_T_cv__VecT_short_3_t_t[] = { {&_swigt__p_cv__Mat_T_cv__VecT_short_3_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__Mat_T_cv__VecT_short_4_t_t[] = { {&_swigt__p_cv__Mat_T_cv__VecT_short_4_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__Mat_T_cv__VecT_uint8_t_2_t_t[] = { {&_swigt__p_cv__Mat_T_cv__VecT_uint8_t_2_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__Mat_T_cv__VecT_uint8_t_3_t_t[] = { {&_swigt__p_cv__Mat_T_cv__VecT_uint8_t_3_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__Mat_T_cv__VecT_uint8_t_4_t_t[] = { {&_swigt__p_cv__Mat_T_cv__VecT_uint8_t_4_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__Mat_T_cv__VecT_ushort_2_t_t[] = { {&_swigt__p_cv__Mat_T_cv__VecT_ushort_2_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__Mat_T_cv__VecT_ushort_3_t_t[] = { {&_swigt__p_cv__Mat_T_cv__VecT_ushort_3_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__Mat_T_cv__VecT_ushort_4_t_t[] = { {&_swigt__p_cv__Mat_T_cv__VecT_ushort_4_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__Mat_T_double_t[] = { {&_swigt__p_cv__Mat_T_double_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__Mat_T_float_t[] = { {&_swigt__p_cv__Mat_T_float_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__Mat_T_int_t[] = { {&_swigt__p_cv__Mat_T_int_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__Mat_T_short_t[] = { {&_swigt__p_cv__Mat_T_short_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__Mat_T_uchar_t[] = { {&_swigt__p_cv__Mat_T_uchar_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__Mat_T_ushort_t[] = { {&_swigt__p_cv__Mat_T_ushort_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__MatxT_double_1_2_t[] = { {&_swigt__p_cv__MatxT_double_1_2_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__MatxT_double_1_3_t[] = { {&_swigt__p_cv__MatxT_double_1_3_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__MatxT_double_1_4_t[] = { {&_swigt__p_cv__MatxT_double_1_4_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__MatxT_double_1_6_t[] = { {&_swigt__p_cv__MatxT_double_1_6_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__MatxT_double_2_1_t[] = { {&_swigt__p_cv__VecT_double_2_t, _p_cv__VecT_double_2_tTo_p_cv__MatxT_double_2_1_t, 0, 0}, {&_swigt__p_cv__MatxT_double_2_1_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__MatxT_double_2_2_t[] = { {&_swigt__p_cv__MatxT_double_2_2_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__MatxT_double_2_3_t[] = { {&_swigt__p_cv__MatxT_double_2_3_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__MatxT_double_3_1_t[] = { {&_swigt__p_cv__MatxT_double_3_1_t, 0, 0, 0}, {&_swigt__p_cv__VecT_double_3_t, _p_cv__VecT_double_3_tTo_p_cv__MatxT_double_3_1_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__MatxT_double_3_2_t[] = { {&_swigt__p_cv__MatxT_double_3_2_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__MatxT_double_3_3_t[] = { {&_swigt__p_cv__MatxT_double_3_3_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__MatxT_double_3_4_t[] = { {&_swigt__p_cv__MatxT_double_3_4_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__MatxT_double_4_1_t[] = { {&_swigt__p_cv__VecT_double_4_t, _p_cv__VecT_double_4_tTo_p_cv__MatxT_double_4_1_t, 0, 0}, {&_swigt__p_cv__MatxT_double_4_1_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__MatxT_double_4_3_t[] = { {&_swigt__p_cv__MatxT_double_4_3_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__MatxT_double_4_4_t[] = { {&_swigt__p_cv__MatxT_double_4_4_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__MatxT_double_6_1_t[] = { {&_swigt__p_cv__MatxT_double_6_1_t, 0, 0, 0}, {&_swigt__p_cv__VecT_double_6_t, _p_cv__VecT_double_6_tTo_p_cv__MatxT_double_6_1_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__MatxT_double_6_6_t[] = { {&_swigt__p_cv__MatxT_double_6_6_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__MatxT_float_1_2_t[] = { {&_swigt__p_cv__MatxT_float_1_2_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__MatxT_float_1_3_t[] = { {&_swigt__p_cv__MatxT_float_1_3_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__MatxT_float_1_4_t[] = { {&_swigt__p_cv__MatxT_float_1_4_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__MatxT_float_1_6_t[] = { {&_swigt__p_cv__MatxT_float_1_6_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__MatxT_float_2_1_t[] = { {&_swigt__p_cv__VecT_float_2_t, _p_cv__VecT_float_2_tTo_p_cv__MatxT_float_2_1_t, 0, 0}, {&_swigt__p_cv__MatxT_float_2_1_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__MatxT_float_2_2_t[] = { {&_swigt__p_cv__MatxT_float_2_2_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__MatxT_float_2_3_t[] = { {&_swigt__p_cv__MatxT_float_2_3_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__MatxT_float_3_1_t[] = { {&_swigt__p_cv__MatxT_float_3_1_t, 0, 0, 0}, {&_swigt__p_cv__VecT_float_3_t, _p_cv__VecT_float_3_tTo_p_cv__MatxT_float_3_1_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__MatxT_float_3_2_t[] = { {&_swigt__p_cv__MatxT_float_3_2_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__MatxT_float_3_3_t[] = { {&_swigt__p_cv__MatxT_float_3_3_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__MatxT_float_3_4_t[] = { {&_swigt__p_cv__MatxT_float_3_4_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__MatxT_float_4_1_t[] = { {&_swigt__p_cv__MatxT_float_4_1_t, 0, 0, 0}, {&_swigt__p_cv__VecT_float_4_t, _p_cv__VecT_float_4_tTo_p_cv__MatxT_float_4_1_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__MatxT_float_4_3_t[] = { {&_swigt__p_cv__MatxT_float_4_3_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__MatxT_float_4_4_t[] = { {&_swigt__p_cv__MatxT_float_4_4_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__MatxT_float_6_1_t[] = { {&_swigt__p_cv__MatxT_float_6_1_t, 0, 0, 0}, {&_swigt__p_cv__VecT_float_6_t, _p_cv__VecT_float_6_tTo_p_cv__MatxT_float_6_1_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__MatxT_float_6_6_t[] = { {&_swigt__p_cv__MatxT_float_6_6_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__MatxT_int_1_2_t[] = { {&_swigt__p_cv__MatxT_int_1_2_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__MatxT_int_1_3_t[] = { {&_swigt__p_cv__MatxT_int_1_3_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__MatxT_int_1_4_t[] = { {&_swigt__p_cv__MatxT_int_1_4_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__MatxT_int_1_6_t[] = { {&_swigt__p_cv__MatxT_int_1_6_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__MatxT_int_1_8_t[] = { {&_swigt__p_cv__MatxT_int_1_8_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__MatxT_int_2_1_t[] = { {&_swigt__p_cv__VecT_int_2_t, _p_cv__VecT_int_2_tTo_p_cv__MatxT_int_2_1_t, 0, 0}, {&_swigt__p_cv__MatxT_int_2_1_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__MatxT_int_3_1_t[] = { {&_swigt__p_cv__VecT_int_3_t, _p_cv__VecT_int_3_tTo_p_cv__MatxT_int_3_1_t, 0, 0}, {&_swigt__p_cv__MatxT_int_3_1_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__MatxT_int_4_1_t[] = { {&_swigt__p_cv__MatxT_int_4_1_t, 0, 0, 0}, {&_swigt__p_cv__VecT_int_4_t, _p_cv__VecT_int_4_tTo_p_cv__MatxT_int_4_1_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__MatxT_int_6_1_t[] = { {&_swigt__p_cv__MatxT_int_6_1_t, 0, 0, 0}, {&_swigt__p_cv__VecT_int_6_t, _p_cv__VecT_int_6_tTo_p_cv__MatxT_int_6_1_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__MatxT_int_8_1_t[] = { {&_swigt__p_cv__MatxT_int_8_1_t, 0, 0, 0}, {&_swigt__p_cv__VecT_int_8_t, _p_cv__VecT_int_8_tTo_p_cv__MatxT_int_8_1_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__MatxT_short_1_2_t[] = { {&_swigt__p_cv__MatxT_short_1_2_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__MatxT_short_1_3_t[] = { {&_swigt__p_cv__MatxT_short_1_3_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__MatxT_short_1_4_t[] = { {&_swigt__p_cv__MatxT_short_1_4_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__MatxT_short_2_1_t[] = { {&_swigt__p_cv__VecT_short_2_t, _p_cv__VecT_short_2_tTo_p_cv__MatxT_short_2_1_t, 0, 0}, {&_swigt__p_cv__MatxT_short_2_1_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__MatxT_short_3_1_t[] = { {&_swigt__p_cv__MatxT_short_3_1_t, 0, 0, 0}, {&_swigt__p_cv__VecT_short_3_t, _p_cv__VecT_short_3_tTo_p_cv__MatxT_short_3_1_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__MatxT_short_4_1_t[] = { {&_swigt__p_cv__MatxT_short_4_1_t, 0, 0, 0}, {&_swigt__p_cv__VecT_short_4_t, _p_cv__VecT_short_4_tTo_p_cv__MatxT_short_4_1_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__MatxT_unsigned_char_1_2_t[] = { {&_swigt__p_cv__MatxT_unsigned_char_1_2_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__MatxT_unsigned_char_1_3_t[] = { {&_swigt__p_cv__MatxT_unsigned_char_1_3_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__MatxT_unsigned_char_1_4_t[] = { {&_swigt__p_cv__MatxT_unsigned_char_1_4_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__MatxT_unsigned_char_2_1_t[] = { {&_swigt__p_cv__VecT_unsigned_char_2_t, _p_cv__VecT_unsigned_char_2_tTo_p_cv__MatxT_unsigned_char_2_1_t, 0, 0}, {&_swigt__p_cv__MatxT_unsigned_char_2_1_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__MatxT_unsigned_char_3_1_t[] = { {&_swigt__p_cv__MatxT_unsigned_char_3_1_t, 0, 0, 0}, {&_swigt__p_cv__VecT_unsigned_char_3_t, _p_cv__VecT_unsigned_char_3_tTo_p_cv__MatxT_unsigned_char_3_1_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__MatxT_unsigned_char_4_1_t[] = { {&_swigt__p_cv__MatxT_unsigned_char_4_1_t, 0, 0, 0}, {&_swigt__p_cv__VecT_unsigned_char_4_t, _p_cv__VecT_unsigned_char_4_tTo_p_cv__MatxT_unsigned_char_4_1_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__MatxT_ushort_1_2_t[] = { {&_swigt__p_cv__MatxT_ushort_1_2_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__MatxT_ushort_1_3_t[] = { {&_swigt__p_cv__MatxT_ushort_1_3_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__MatxT_ushort_1_4_t[] = { {&_swigt__p_cv__MatxT_ushort_1_4_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__MatxT_ushort_2_1_t[] = { {&_swigt__p_cv__VecT_ushort_2_t, _p_cv__VecT_ushort_2_tTo_p_cv__MatxT_ushort_2_1_t, 0, 0}, {&_swigt__p_cv__MatxT_ushort_2_1_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__MatxT_ushort_3_1_t[] = { {&_swigt__p_cv__MatxT_ushort_3_1_t, 0, 0, 0}, {&_swigt__p_cv__VecT_ushort_3_t, _p_cv__VecT_ushort_3_tTo_p_cv__MatxT_ushort_3_1_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__MatxT_ushort_4_1_t[] = { {&_swigt__p_cv__MatxT_ushort_4_1_t, 0, 0, 0}, {&_swigt__p_cv__VecT_ushort_4_t, _p_cv__VecT_ushort_4_tTo_p_cv__MatxT_ushort_4_1_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__Matx_AddOp[] = { {&_swigt__p_cv__Matx_AddOp, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__Matx_DivOp[] = { {&_swigt__p_cv__Matx_DivOp, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__Matx_MatMulOp[] = { {&_swigt__p_cv__Matx_MatMulOp, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__Matx_MulOp[] = { {&_swigt__p_cv__Matx_MulOp, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__Matx_ScaleOp[] = { {&_swigt__p_cv__Matx_ScaleOp, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__Matx_SubOp[] = { {&_swigt__p_cv__Matx_SubOp, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__Matx_TOp[] = { {&_swigt__p_cv__Matx_TOp, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__Point_T_double_t[] = { {&_swigt__p_cv__Point_T_double_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__Point_T_float_t[] = { {&_swigt__p_cv__Point_T_float_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__Point_T_int_t[] = { {&_swigt__p_cv__Point_T_int_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__Range[] = { {&_swigt__p_cv__Range, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__Rect_T_double_t[] = { {&_swigt__p_cv__Rect_T_double_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__Rect_T_float_t[] = { {&_swigt__p_cv__Rect_T_float_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__Rect_T_int_t[] = { {&_swigt__p_cv__Rect_T_int_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__Scalar_T_double_t[] = { {&_swigt__p_cv__Scalar_T_double_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__Size_T_double_t[] = { {&_swigt__p_cv__Size_T_double_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__Size_T_float_t[] = { {&_swigt__p_cv__Size_T_float_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__Size_T_int_t[] = { {&_swigt__p_cv__Size_T_int_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__VecT_double_2_t[] = { {&_swigt__p_cv__VecT_double_2_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__VecT_double_3_t[] = { {&_swigt__p_cv__VecT_double_3_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__VecT_double_4_t[] = { {&_swigt__p_cv__VecT_double_4_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__VecT_double_6_t[] = { {&_swigt__p_cv__VecT_double_6_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__VecT_float_2_t[] = { {&_swigt__p_cv__VecT_float_2_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__VecT_float_3_t[] = { {&_swigt__p_cv__VecT_float_3_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__VecT_float_4_t[] = { {&_swigt__p_cv__VecT_float_4_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__VecT_float_6_t[] = { {&_swigt__p_cv__VecT_float_6_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__VecT_int_2_t[] = { {&_swigt__p_cv__VecT_int_2_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__VecT_int_3_t[] = { {&_swigt__p_cv__VecT_int_3_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__VecT_int_4_t[] = { {&_swigt__p_cv__VecT_int_4_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__VecT_int_6_t[] = { {&_swigt__p_cv__VecT_int_6_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__VecT_int_8_t[] = { {&_swigt__p_cv__VecT_int_8_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__VecT_short_2_t[] = { {&_swigt__p_cv__VecT_short_2_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__VecT_short_3_t[] = { {&_swigt__p_cv__VecT_short_3_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__VecT_short_4_t[] = { {&_swigt__p_cv__VecT_short_4_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__VecT_unsigned_char_2_t[] = { {&_swigt__p_cv__VecT_unsigned_char_2_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__VecT_unsigned_char_3_t[] = { {&_swigt__p_cv__VecT_unsigned_char_3_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__VecT_unsigned_char_4_t[] = { {&_swigt__p_cv__VecT_unsigned_char_4_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__VecT_ushort_2_t[] = { {&_swigt__p_cv__VecT_ushort_2_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__VecT_ushort_3_t[] = { {&_swigt__p_cv__VecT_ushort_3_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv__VecT_ushort_4_t[] = { {&_swigt__p_cv__VecT_ushort_4_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv___SizeOfT_double_t[] = { {&_swigt__p_cv___SizeOfT_double_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv___SizeOfT_float_t[] = { {&_swigt__p_cv___SizeOfT_float_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv___SizeOfT_int_t[] = { {&_swigt__p_cv___SizeOfT_int_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv___SizeOfT_short_t[] = { {&_swigt__p_cv___SizeOfT_short_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv___SizeOfT_unsigned_char_t[] = { {&_swigt__p_cv___SizeOfT_unsigned_char_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cv___SizeOfT_ushort_t[] = { {&_swigt__p_cv___SizeOfT_ushort_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_diag_type[] = { {&_swigt__p_diag_type, 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_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_mat_type[] = { {&_swigt__p_mat_type, 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_sPerfProfileParam[] = { {&_swigt__p_sPerfProfileParam, 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__allocatorT_double_t[] = { {&_swigt__p_std__allocatorT_double_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_float_t[] = { {&_swigt__p_std__allocatorT_float_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_int_t[] = { {&_swigt__p_std__allocatorT_int_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_short_t[] = { {&_swigt__p_std__allocatorT_short_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_unsigned_char_t[] = { {&_swigt__p_std__allocatorT_unsigned_char_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_ushort_t[] = { {&_swigt__p_std__allocatorT_ushort_t, 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_double_std__allocatorT_double_t_t[] = { {&_swigt__p_std__vectorT_double_std__allocatorT_double_t_t, 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_int_std__allocatorT_int_t_t[] = { {&_swigt__p_std__vectorT_int_std__allocatorT_int_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_short_std__allocatorT_short_t_t[] = { {&_swigt__p_std__vectorT_short_std__allocatorT_short_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t[] = { {&_swigt__p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_ushort_std__allocatorT_ushort_t_t[] = { {&_swigt__p_std__vectorT_ushort_std__allocatorT_ushort_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_swig__SwigPyIterator[] = { {&_swigt__p_swig__SwigPyIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_uchar[] = { {&_swigt__p_uchar, 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_ushort[] = { {&_swigt__p_ushort, 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_vec_type[] = { {&_swigt__p_vec_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 _swigc__p_work_type[] = { {&_swigt__p_work_type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info *swig_cast_initial[] = {
_swigc__p_CmDevice,
_swigc__p_InputParamMap,
_swigc__p_KCFTracker,
_swigc__p_Tracker,
_swigc__p__mat__np_array_constructor,
_swigc__p_allocator_type,
_swigc__p_channel_type,
_swigc__p_char,
_swigc__p_cv__DataTypeT_bool_t,
_swigc__p_cv__DataTypeT_char_t,
_swigc__p_cv__DataTypeT_cv__VecT_double_2_t_t,
_swigc__p_cv__DataTypeT_cv__VecT_double_3_t_t,
_swigc__p_cv__DataTypeT_cv__VecT_double_4_t_t,
_swigc__p_cv__DataTypeT_cv__VecT_double_6_t_t,
_swigc__p_cv__DataTypeT_cv__VecT_float_2_t_t,
_swigc__p_cv__DataTypeT_cv__VecT_float_3_t_t,
_swigc__p_cv__DataTypeT_cv__VecT_float_4_t_t,
_swigc__p_cv__DataTypeT_cv__VecT_float_6_t_t,
_swigc__p_cv__DataTypeT_cv__VecT_int_2_t_t,
_swigc__p_cv__DataTypeT_cv__VecT_int_3_t_t,
_swigc__p_cv__DataTypeT_cv__VecT_int_4_t_t,
_swigc__p_cv__DataTypeT_cv__VecT_int_6_t_t,
_swigc__p_cv__DataTypeT_cv__VecT_int_8_t_t,
_swigc__p_cv__DataTypeT_cv__VecT_short_2_t_t,
_swigc__p_cv__DataTypeT_cv__VecT_short_3_t_t,
_swigc__p_cv__DataTypeT_cv__VecT_short_4_t_t,
_swigc__p_cv__DataTypeT_cv__VecT_uint8_t_2_t_t,
_swigc__p_cv__DataTypeT_cv__VecT_uint8_t_3_t_t,
_swigc__p_cv__DataTypeT_cv__VecT_uint8_t_4_t_t,
_swigc__p_cv__DataTypeT_cv__VecT_ushort_2_t_t,
_swigc__p_cv__DataTypeT_cv__VecT_ushort_3_t_t,
_swigc__p_cv__DataTypeT_cv__VecT_ushort_4_t_t,
_swigc__p_cv__DataTypeT_double_t,
_swigc__p_cv__DataTypeT_float_t,
_swigc__p_cv__DataTypeT_int_t,
_swigc__p_cv__DataTypeT_schar_t,
_swigc__p_cv__DataTypeT_short_t,
_swigc__p_cv__DataTypeT_uchar_t,
_swigc__p_cv__DataTypeT_ushort_t,
_swigc__p_cv__Mat,
_swigc__p_cv__Mat_T_cv__VecT_double_2_t_t,
_swigc__p_cv__Mat_T_cv__VecT_double_3_t_t,
_swigc__p_cv__Mat_T_cv__VecT_double_4_t_t,
_swigc__p_cv__Mat_T_cv__VecT_float_2_t_t,
_swigc__p_cv__Mat_T_cv__VecT_float_3_t_t,
_swigc__p_cv__Mat_T_cv__VecT_float_4_t_t,
_swigc__p_cv__Mat_T_cv__VecT_int_2_t_t,
_swigc__p_cv__Mat_T_cv__VecT_int_3_t_t,
_swigc__p_cv__Mat_T_cv__VecT_int_4_t_t,
_swigc__p_cv__Mat_T_cv__VecT_short_2_t_t,
_swigc__p_cv__Mat_T_cv__VecT_short_3_t_t,
_swigc__p_cv__Mat_T_cv__VecT_short_4_t_t,
_swigc__p_cv__Mat_T_cv__VecT_uint8_t_2_t_t,
_swigc__p_cv__Mat_T_cv__VecT_uint8_t_3_t_t,
_swigc__p_cv__Mat_T_cv__VecT_uint8_t_4_t_t,
_swigc__p_cv__Mat_T_cv__VecT_ushort_2_t_t,
_swigc__p_cv__Mat_T_cv__VecT_ushort_3_t_t,
_swigc__p_cv__Mat_T_cv__VecT_ushort_4_t_t,
_swigc__p_cv__Mat_T_double_t,
_swigc__p_cv__Mat_T_float_t,
_swigc__p_cv__Mat_T_int_t,
_swigc__p_cv__Mat_T_short_t,
_swigc__p_cv__Mat_T_uchar_t,
_swigc__p_cv__Mat_T_ushort_t,
_swigc__p_cv__MatxT_double_1_2_t,
_swigc__p_cv__MatxT_double_1_3_t,
_swigc__p_cv__MatxT_double_1_4_t,
_swigc__p_cv__MatxT_double_1_6_t,
_swigc__p_cv__MatxT_double_2_1_t,
_swigc__p_cv__MatxT_double_2_2_t,
_swigc__p_cv__MatxT_double_2_3_t,
_swigc__p_cv__MatxT_double_3_1_t,
_swigc__p_cv__MatxT_double_3_2_t,
_swigc__p_cv__MatxT_double_3_3_t,
_swigc__p_cv__MatxT_double_3_4_t,
_swigc__p_cv__MatxT_double_4_1_t,
_swigc__p_cv__MatxT_double_4_3_t,
_swigc__p_cv__MatxT_double_4_4_t,
_swigc__p_cv__MatxT_double_6_1_t,
_swigc__p_cv__MatxT_double_6_6_t,
_swigc__p_cv__MatxT_float_1_2_t,
_swigc__p_cv__MatxT_float_1_3_t,
_swigc__p_cv__MatxT_float_1_4_t,
_swigc__p_cv__MatxT_float_1_6_t,
_swigc__p_cv__MatxT_float_2_1_t,
_swigc__p_cv__MatxT_float_2_2_t,
_swigc__p_cv__MatxT_float_2_3_t,
_swigc__p_cv__MatxT_float_3_1_t,
_swigc__p_cv__MatxT_float_3_2_t,
_swigc__p_cv__MatxT_float_3_3_t,
_swigc__p_cv__MatxT_float_3_4_t,
_swigc__p_cv__MatxT_float_4_1_t,
_swigc__p_cv__MatxT_float_4_3_t,
_swigc__p_cv__MatxT_float_4_4_t,
_swigc__p_cv__MatxT_float_6_1_t,
_swigc__p_cv__MatxT_float_6_6_t,
_swigc__p_cv__MatxT_int_1_2_t,
_swigc__p_cv__MatxT_int_1_3_t,
_swigc__p_cv__MatxT_int_1_4_t,
_swigc__p_cv__MatxT_int_1_6_t,
_swigc__p_cv__MatxT_int_1_8_t,
_swigc__p_cv__MatxT_int_2_1_t,
_swigc__p_cv__MatxT_int_3_1_t,
_swigc__p_cv__MatxT_int_4_1_t,
_swigc__p_cv__MatxT_int_6_1_t,
_swigc__p_cv__MatxT_int_8_1_t,
_swigc__p_cv__MatxT_short_1_2_t,
_swigc__p_cv__MatxT_short_1_3_t,
_swigc__p_cv__MatxT_short_1_4_t,
_swigc__p_cv__MatxT_short_2_1_t,
_swigc__p_cv__MatxT_short_3_1_t,
_swigc__p_cv__MatxT_short_4_1_t,
_swigc__p_cv__MatxT_unsigned_char_1_2_t,
_swigc__p_cv__MatxT_unsigned_char_1_3_t,
_swigc__p_cv__MatxT_unsigned_char_1_4_t,
_swigc__p_cv__MatxT_unsigned_char_2_1_t,
_swigc__p_cv__MatxT_unsigned_char_3_1_t,
_swigc__p_cv__MatxT_unsigned_char_4_1_t,
_swigc__p_cv__MatxT_ushort_1_2_t,
_swigc__p_cv__MatxT_ushort_1_3_t,
_swigc__p_cv__MatxT_ushort_1_4_t,
_swigc__p_cv__MatxT_ushort_2_1_t,
_swigc__p_cv__MatxT_ushort_3_1_t,
_swigc__p_cv__MatxT_ushort_4_1_t,
_swigc__p_cv__Matx_AddOp,
_swigc__p_cv__Matx_DivOp,
_swigc__p_cv__Matx_MatMulOp,
_swigc__p_cv__Matx_MulOp,
_swigc__p_cv__Matx_ScaleOp,
_swigc__p_cv__Matx_SubOp,
_swigc__p_cv__Matx_TOp,
_swigc__p_cv__Point_T_double_t,
_swigc__p_cv__Point_T_float_t,
_swigc__p_cv__Point_T_int_t,
_swigc__p_cv__Range,
_swigc__p_cv__Rect_T_double_t,
_swigc__p_cv__Rect_T_float_t,
_swigc__p_cv__Rect_T_int_t,
_swigc__p_cv__Scalar_T_double_t,
_swigc__p_cv__Size_T_double_t,
_swigc__p_cv__Size_T_float_t,
_swigc__p_cv__Size_T_int_t,
_swigc__p_cv__VecT_double_2_t,
_swigc__p_cv__VecT_double_3_t,
_swigc__p_cv__VecT_double_4_t,
_swigc__p_cv__VecT_double_6_t,
_swigc__p_cv__VecT_float_2_t,
_swigc__p_cv__VecT_float_3_t,
_swigc__p_cv__VecT_float_4_t,
_swigc__p_cv__VecT_float_6_t,
_swigc__p_cv__VecT_int_2_t,
_swigc__p_cv__VecT_int_3_t,
_swigc__p_cv__VecT_int_4_t,
_swigc__p_cv__VecT_int_6_t,
_swigc__p_cv__VecT_int_8_t,
_swigc__p_cv__VecT_short_2_t,
_swigc__p_cv__VecT_short_3_t,
_swigc__p_cv__VecT_short_4_t,
_swigc__p_cv__VecT_unsigned_char_2_t,
_swigc__p_cv__VecT_unsigned_char_3_t,
_swigc__p_cv__VecT_unsigned_char_4_t,
_swigc__p_cv__VecT_ushort_2_t,
_swigc__p_cv__VecT_ushort_3_t,
_swigc__p_cv__VecT_ushort_4_t,
_swigc__p_cv___SizeOfT_double_t,
_swigc__p_cv___SizeOfT_float_t,
_swigc__p_cv___SizeOfT_int_t,
_swigc__p_cv___SizeOfT_short_t,
_swigc__p_cv___SizeOfT_unsigned_char_t,
_swigc__p_cv___SizeOfT_ushort_t,
_swigc__p_diag_type,
_swigc__p_difference_type,
_swigc__p_double,
_swigc__p_float,
_swigc__p_int,
_swigc__p_long_long,
_swigc__p_mat_type,
_swigc__p_p_PyObject,
_swigc__p_sPerfProfileParam,
_swigc__p_short,
_swigc__p_signed_char,
_swigc__p_size_t,
_swigc__p_size_type,
_swigc__p_std__allocatorT_double_t,
_swigc__p_std__allocatorT_float_t,
_swigc__p_std__allocatorT_int_t,
_swigc__p_std__allocatorT_short_t,
_swigc__p_std__allocatorT_unsigned_char_t,
_swigc__p_std__allocatorT_ushort_t,
_swigc__p_std__invalid_argument,
_swigc__p_std__vectorT_double_std__allocatorT_double_t_t,
_swigc__p_std__vectorT_float_std__allocatorT_float_t_t,
_swigc__p_std__vectorT_int_std__allocatorT_int_t_t,
_swigc__p_std__vectorT_short_std__allocatorT_short_t_t,
_swigc__p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t,
_swigc__p_std__vectorT_ushort_std__allocatorT_ushort_t_t,
_swigc__p_swig__SwigPyIterator,
_swigc__p_uchar,
_swigc__p_unsigned_char,
_swigc__p_unsigned_int,
_swigc__p_unsigned_long_long,
_swigc__p_unsigned_short,
_swigc__p_ushort,
_swigc__p_value_type,
_swigc__p_vec_type,
_swigc__p_void,
_swigc__p_work_type,
};
/* -------- 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 statically 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 init;
/* 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);
} else {
/* the interpreter has loaded a SWIG module, but has it loaded this one? */
iter=module_head;
do {
if (iter==&swig_module) {
/* Our module is already in the list, so there's nothing more to do. */
return;
}
iter=iter->next;
} while (iter!= module_head);
/* otherwise we must add our module into the list */
swig_module.next = module_head->next;
module_head->next = &swig_module;
}
/* When multiple interpreters 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)) {
#if PY_VERSION_HEX >= 0x03000000
return PyUnicode_InternFromString("<Swig global variables>");
#else
return PyString_FromString("<Swig global variables>");
#endif
}
SWIGINTERN PyObject *
swig_varlink_str(swig_varlinkobject *v) {
#if PY_VERSION_HEX >= 0x03000000
PyObject *str = PyUnicode_InternFromString("(");
PyObject *tail;
PyObject *joined;
swig_globalvar *var;
for (var = v->vars; var; var=var->next) {
tail = PyUnicode_FromString(var->name);
joined = PyUnicode_Concat(str, tail);
Py_DecRef(str);
Py_DecRef(tail);
str = joined;
if (var->next) {
tail = PyUnicode_InternFromString(", ");
joined = PyUnicode_Concat(str, tail);
Py_DecRef(str);
Py_DecRef(tail);
str = joined;
}
}
tail = PyUnicode_InternFromString(")");
joined = PyUnicode_Concat(str, tail);
Py_DecRef(str);
Py_DecRef(tail);
str = joined;
#else
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(")"));
#endif
return str;
}
SWIGINTERN int
swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
char *tmp;
PyObject *str = swig_varlink_str(v);
fprintf(fp,"Swig global variables ");
fprintf(fp,"%s\n", tmp = SWIG_Python_str_AsChar(str));
SWIG_Python_str_DelForPy3(tmp);
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_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
}
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_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
}
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 header changed in Python 3 */
#if PY_VERSION_HEX >= 0x03000000
PyVarObject_HEAD_INIT(NULL, 0)
#else
PyObject_HEAD_INIT(NULL)
0, /* ob_size */
#endif
(char *)"swigvarlink", /* tp_name */
sizeof(swig_varlinkobject), /* tp_basicsize */
0, /* tp_itemsize */
(destructor) swig_varlink_dealloc, /* tp_dealloc */
(printfunc) swig_varlink_print, /* tp_print */
(getattrfunc) swig_varlink_getattr, /* tp_getattr */
(setattrfunc) swig_varlink_setattr, /* 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
#if PY_VERSION_HEX >= 0x02060000
0, /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
0, /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
0, /* tp_allocs */
0, /* tp_frees */
0, /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
0, /* tp_prev */
#endif
0 /* tp_next */
#endif
};
varlink_type = tmp;
type_init = 1;
#if PY_VERSION_HEX < 0x02020000
varlink_type.ob_type = &PyType_Type;
#else
if (PyType_Ready(&varlink_type) < 0)
return NULL;
#endif
}
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_InternalNewPointerObj(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 = methods[i].ml_doc;
if (!c) continue;
c = strstr(c, "swig_ptr: ");
if (c) {
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) {
void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
if (ptr) {
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;
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
#if PY_VERSION_HEX >= 0x03000000
PyObject*
#else
void
#endif
SWIG_init(void) {
PyObject *m, *d, *md;
#if PY_VERSION_HEX >= 0x03000000
static struct PyModuleDef SWIG_module = {
# if PY_VERSION_HEX >= 0x03020000
PyModuleDef_HEAD_INIT,
# else
{
PyObject_HEAD_INIT(NULL)
NULL, /* m_init */
0, /* m_index */
NULL, /* m_copy */
},
# endif
(char *) SWIG_name,
NULL,
-1,
SwigMethods,
NULL,
NULL,
NULL,
NULL
};
#endif
#if defined(SWIGPYTHON_BUILTIN)
static SwigPyClientData SwigPyObject_clientdata = {
0, 0, 0, 0, 0, 0, 0
};
static PyGetSetDef this_getset_def = {
(char *)"this", &SwigPyBuiltin_ThisClosure, NULL, NULL, NULL
};
static SwigPyGetSet thisown_getset_closure = {
(PyCFunction) SwigPyObject_own,
(PyCFunction) SwigPyObject_own
};
static PyGetSetDef thisown_getset_def = {
(char *)"thisown", SwigPyBuiltin_GetterClosure, SwigPyBuiltin_SetterClosure, NULL, &thisown_getset_closure
};
PyObject *metatype_args;
PyTypeObject *builtin_pytype;
int builtin_base_count;
swig_type_info *builtin_basetype;
PyObject *tuple;
PyGetSetDescrObject *static_getset;
PyTypeObject *metatype;
SwigPyClientData *cd;
PyObject *public_interface, *public_symbol;
PyObject *this_descr;
PyObject *thisown_descr;
PyObject *self = 0;
int i;
(void)builtin_pytype;
(void)builtin_base_count;
(void)builtin_basetype;
(void)tuple;
(void)static_getset;
(void)self;
/* metatype is used to implement static member variables. */
metatype_args = Py_BuildValue("(s(O){})", "SwigPyObjectType", &PyType_Type);
assert(metatype_args);
metatype = (PyTypeObject *) PyType_Type.tp_call((PyObject *) &PyType_Type, metatype_args, NULL);
assert(metatype);
Py_DECREF(metatype_args);
metatype->tp_setattro = (setattrofunc) &SwigPyObjectType_setattro;
assert(PyType_Ready(metatype) >= 0);
#endif
/* Fix SwigMethods to carry the callback ptrs when needed */
SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
#if PY_VERSION_HEX >= 0x03000000
m = PyModule_Create(&SWIG_module);
#else
m = Py_InitModule((char *) SWIG_name, SwigMethods);
#endif
md = d = PyModule_GetDict(m);
(void)md;
SWIG_InitializeModule(0);
#ifdef SWIGPYTHON_BUILTIN
SwigPyObject_stype = SWIG_MangledTypeQuery("_p_SwigPyObject");
assert(SwigPyObject_stype);
cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
if (!cd) {
SwigPyObject_stype->clientdata = &SwigPyObject_clientdata;
SwigPyObject_clientdata.pytype = SwigPyObject_TypeOnce();
} else if (SwigPyObject_TypeOnce()->tp_basicsize != cd->pytype->tp_basicsize) {
PyErr_SetString(PyExc_RuntimeError, "Import error: attempted to load two incompatible swig-generated modules.");
# if PY_VERSION_HEX >= 0x03000000
return NULL;
# else
return;
# endif
}
/* All objects have a 'this' attribute */
this_descr = PyDescr_NewGetSet(SwigPyObject_type(), &this_getset_def);
(void)this_descr;
/* All objects have a 'thisown' attribute */
thisown_descr = PyDescr_NewGetSet(SwigPyObject_type(), &thisown_getset_def);
(void)thisown_descr;
public_interface = PyList_New(0);
public_symbol = 0;
(void)public_symbol;
PyDict_SetItemString(md, "__all__", public_interface);
Py_DECREF(public_interface);
for (i = 0; SwigMethods[i].ml_name != NULL; ++i)
SwigPyBuiltin_AddPublicSymbol(public_interface, SwigMethods[i].ml_name);
for (i = 0; swig_const_table[i].name != 0; ++i)
SwigPyBuiltin_AddPublicSymbol(public_interface, swig_const_table[i].name);
#endif
SWIG_InstallConstants(d,swig_const_table);
SWIG_Python_SetConstant(d, "DataType_bool_generic_type",SWIG_From_int(static_cast< int >(cv::DataType< bool >::generic_type)));
SWIG_Python_SetConstant(d, "DataType_bool_channels",SWIG_From_int(static_cast< int >(cv::DataType< bool >::channels)));
SWIG_Python_SetConstant(d, "DataType_bool_fmt",SWIG_From_char(static_cast< char >(cv::DataType< bool >::fmt)));
SWIG_Python_SetConstant(d, "DataType_uchar_generic_type",SWIG_From_int(static_cast< int >(cv::DataType< uchar >::generic_type)));
SWIG_Python_SetConstant(d, "DataType_uchar_channels",SWIG_From_int(static_cast< int >(cv::DataType< uchar >::channels)));
SWIG_Python_SetConstant(d, "DataType_uchar_fmt",SWIG_From_char(static_cast< char >(cv::DataType< uchar >::fmt)));
SWIG_Python_SetConstant(d, "DataType_schar_generic_type",SWIG_From_int(static_cast< int >(cv::DataType< schar >::generic_type)));
SWIG_Python_SetConstant(d, "DataType_schar_channels",SWIG_From_int(static_cast< int >(cv::DataType< schar >::channels)));
SWIG_Python_SetConstant(d, "DataType_schar_fmt",SWIG_From_char(static_cast< char >(cv::DataType< schar >::fmt)));
SWIG_Python_SetConstant(d, "DataType_char_generic_type",SWIG_From_int(static_cast< int >(cv::DataType< char >::generic_type)));
SWIG_Python_SetConstant(d, "DataType_char_channels",SWIG_From_int(static_cast< int >(cv::DataType< char >::channels)));
SWIG_Python_SetConstant(d, "DataType_char_fmt",SWIG_From_char(static_cast< char >(cv::DataType< char >::fmt)));
SWIG_Python_SetConstant(d, "DataType_ushort_generic_type",SWIG_From_int(static_cast< int >(cv::DataType< ushort >::generic_type)));
SWIG_Python_SetConstant(d, "DataType_ushort_channels",SWIG_From_int(static_cast< int >(cv::DataType< ushort >::channels)));
SWIG_Python_SetConstant(d, "DataType_ushort_fmt",SWIG_From_char(static_cast< char >(cv::DataType< ushort >::fmt)));
SWIG_Python_SetConstant(d, "DataType_short_generic_type",SWIG_From_int(static_cast< int >(cv::DataType< short >::generic_type)));
SWIG_Python_SetConstant(d, "DataType_short_channels",SWIG_From_int(static_cast< int >(cv::DataType< short >::channels)));
SWIG_Python_SetConstant(d, "DataType_short_fmt",SWIG_From_char(static_cast< char >(cv::DataType< short >::fmt)));
SWIG_Python_SetConstant(d, "DataType_int_generic_type",SWIG_From_int(static_cast< int >(cv::DataType< int >::generic_type)));
SWIG_Python_SetConstant(d, "DataType_int_channels",SWIG_From_int(static_cast< int >(cv::DataType< int >::channels)));
SWIG_Python_SetConstant(d, "DataType_int_fmt",SWIG_From_char(static_cast< char >(cv::DataType< int >::fmt)));
SWIG_Python_SetConstant(d, "DataType_float_generic_type",SWIG_From_int(static_cast< int >(cv::DataType< float >::generic_type)));
SWIG_Python_SetConstant(d, "DataType_float_channels",SWIG_From_int(static_cast< int >(cv::DataType< float >::channels)));
SWIG_Python_SetConstant(d, "DataType_float_fmt",SWIG_From_char(static_cast< char >(cv::DataType< float >::fmt)));
SWIG_Python_SetConstant(d, "DataType_double_generic_type",SWIG_From_int(static_cast< int >(cv::DataType< double >::generic_type)));
SWIG_Python_SetConstant(d, "DataType_double_channels",SWIG_From_int(static_cast< int >(cv::DataType< double >::channels)));
SWIG_Python_SetConstant(d, "DataType_double_fmt",SWIG_From_char(static_cast< char >(cv::DataType< double >::fmt)));
SWIG_Python_SetConstant(d, "Mat_MAGIC_VAL",SWIG_From_int(static_cast< int >(cv::Mat::MAGIC_VAL)));
SWIG_Python_SetConstant(d, "Mat_AUTO_STEP",SWIG_From_int(static_cast< int >(cv::Mat::AUTO_STEP)));
SWIG_Python_SetConstant(d, "Mat_CONTINUOUS_FLAG",SWIG_From_int(static_cast< int >(cv::Mat::CONTINUOUS_FLAG)));
SWIG_Python_SetConstant(d, "Mat_SUBMATRIX_FLAG",SWIG_From_int(static_cast< int >(cv::Mat::SUBMATRIX_FLAG)));
SWIG_Python_SetConstant(d, "Mat_MAGIC_MASK",SWIG_From_int(static_cast< int >(cv::Mat::MAGIC_MASK)));
SWIG_Python_SetConstant(d, "Mat_TYPE_MASK",SWIG_From_int(static_cast< int >(cv::Mat::TYPE_MASK)));
SWIG_Python_SetConstant(d, "Mat_DEPTH_MASK",SWIG_From_int(static_cast< int >(cv::Mat::DEPTH_MASK)));
SWIG_Python_SetConstant(d, "_cv_numpy_sizeof_uint8_t_value",SWIG_From_int(static_cast< int >(cv::_SizeOf< uint8_t >::value)));
SWIG_Python_SetConstant(d, "_Matx_uint8_t_2_1_rows",SWIG_From_int(static_cast< int >(cv::Matx< uint8_t,2,1 >::rows)));
SWIG_Python_SetConstant(d, "_Matx_uint8_t_2_1_cols",SWIG_From_int(static_cast< int >(cv::Matx< uint8_t,2,1 >::cols)));
SWIG_Python_SetConstant(d, "_Matx_uint8_t_2_1_channels",SWIG_From_int(static_cast< int >(cv::Matx< uint8_t,2,1 >::channels)));
SWIG_Python_SetConstant(d, "_Matx_uint8_t_2_1_shortdim",SWIG_From_int(static_cast< int >(cv::Matx< uint8_t,2,1 >::shortdim)));
SWIG_Python_SetConstant(d, "_Vec_uint8_t_2_channels",SWIG_From_int(static_cast< int >(cv::Vec< uint8_t,2 >::channels)));
SWIG_Python_SetConstant(d, "_DataType_Vec_uint8_t_2_generic_type",SWIG_From_int(static_cast< int >(cv::DataType< cv::Vec< uint8_t,2 > >::generic_type)));
SWIG_Python_SetConstant(d, "_DataType_Vec_uint8_t_2_channels",SWIG_From_int(static_cast< int >(cv::DataType< cv::Vec< uint8_t,2 > >::channels)));
SWIG_Python_SetConstant(d, "_DataType_Vec_uint8_t_2_fmt",SWIG_From_int(static_cast< int >(cv::DataType< cv::Vec< uint8_t,2 > >::fmt)));
SWIG_Python_SetConstant(d, "_Matx_uint8_t_3_1_rows",SWIG_From_int(static_cast< int >(cv::Matx< uint8_t,3,1 >::rows)));
SWIG_Python_SetConstant(d, "_Matx_uint8_t_3_1_cols",SWIG_From_int(static_cast< int >(cv::Matx< uint8_t,3,1 >::cols)));
SWIG_Python_SetConstant(d, "_Matx_uint8_t_3_1_channels",SWIG_From_int(static_cast< int >(cv::Matx< uint8_t,3,1 >::channels)));
SWIG_Python_SetConstant(d, "_Matx_uint8_t_3_1_shortdim",SWIG_From_int(static_cast< int >(cv::Matx< uint8_t,3,1 >::shortdim)));
SWIG_Python_SetConstant(d, "_Vec_uint8_t_3_channels",SWIG_From_int(static_cast< int >(cv::Vec< uint8_t,3 >::channels)));
SWIG_Python_SetConstant(d, "_DataType_Vec_uint8_t_3_generic_type",SWIG_From_int(static_cast< int >(cv::DataType< cv::Vec< uint8_t,3 > >::generic_type)));
SWIG_Python_SetConstant(d, "_DataType_Vec_uint8_t_3_channels",SWIG_From_int(static_cast< int >(cv::DataType< cv::Vec< uint8_t,3 > >::channels)));
SWIG_Python_SetConstant(d, "_DataType_Vec_uint8_t_3_fmt",SWIG_From_int(static_cast< int >(cv::DataType< cv::Vec< uint8_t,3 > >::fmt)));
SWIG_Python_SetConstant(d, "_Matx_uint8_t_4_1_rows",SWIG_From_int(static_cast< int >(cv::Matx< uint8_t,4,1 >::rows)));
SWIG_Python_SetConstant(d, "_Matx_uint8_t_4_1_cols",SWIG_From_int(static_cast< int >(cv::Matx< uint8_t,4,1 >::cols)));
SWIG_Python_SetConstant(d, "_Matx_uint8_t_4_1_channels",SWIG_From_int(static_cast< int >(cv::Matx< uint8_t,4,1 >::channels)));
SWIG_Python_SetConstant(d, "_Matx_uint8_t_4_1_shortdim",SWIG_From_int(static_cast< int >(cv::Matx< uint8_t,4,1 >::shortdim)));
SWIG_Python_SetConstant(d, "_Vec_uint8_t_4_channels",SWIG_From_int(static_cast< int >(cv::Vec< uint8_t,4 >::channels)));
SWIG_Python_SetConstant(d, "_DataType_Vec_uint8_t_4_generic_type",SWIG_From_int(static_cast< int >(cv::DataType< cv::Vec< uint8_t,4 > >::generic_type)));
SWIG_Python_SetConstant(d, "_DataType_Vec_uint8_t_4_channels",SWIG_From_int(static_cast< int >(cv::DataType< cv::Vec< uint8_t,4 > >::channels)));
SWIG_Python_SetConstant(d, "_DataType_Vec_uint8_t_4_fmt",SWIG_From_int(static_cast< int >(cv::DataType< cv::Vec< uint8_t,4 > >::fmt)));
SWIG_Python_SetConstant(d, "_cv_numpy_sizeof_short_value",SWIG_From_int(static_cast< int >(cv::_SizeOf< short >::value)));
SWIG_Python_SetConstant(d, "_Matx_short_2_1_rows",SWIG_From_int(static_cast< int >(cv::Matx< short,2,1 >::rows)));
SWIG_Python_SetConstant(d, "_Matx_short_2_1_cols",SWIG_From_int(static_cast< int >(cv::Matx< short,2,1 >::cols)));
SWIG_Python_SetConstant(d, "_Matx_short_2_1_channels",SWIG_From_int(static_cast< int >(cv::Matx< short,2,1 >::channels)));
SWIG_Python_SetConstant(d, "_Matx_short_2_1_shortdim",SWIG_From_int(static_cast< int >(cv::Matx< short,2,1 >::shortdim)));
SWIG_Python_SetConstant(d, "_Vec_short_2_channels",SWIG_From_int(static_cast< int >(cv::Vec< short,2 >::channels)));
SWIG_Python_SetConstant(d, "_DataType_Vec_short_2_generic_type",SWIG_From_int(static_cast< int >(cv::DataType< cv::Vec< short,2 > >::generic_type)));
SWIG_Python_SetConstant(d, "_DataType_Vec_short_2_channels",SWIG_From_int(static_cast< int >(cv::DataType< cv::Vec< short,2 > >::channels)));
SWIG_Python_SetConstant(d, "_DataType_Vec_short_2_fmt",SWIG_From_int(static_cast< int >(cv::DataType< cv::Vec< short,2 > >::fmt)));
SWIG_Python_SetConstant(d, "_Matx_short_3_1_rows",SWIG_From_int(static_cast< int >(cv::Matx< short,3,1 >::rows)));
SWIG_Python_SetConstant(d, "_Matx_short_3_1_cols",SWIG_From_int(static_cast< int >(cv::Matx< short,3,1 >::cols)));
SWIG_Python_SetConstant(d, "_Matx_short_3_1_channels",SWIG_From_int(static_cast< int >(cv::Matx< short,3,1 >::channels)));
SWIG_Python_SetConstant(d, "_Matx_short_3_1_shortdim",SWIG_From_int(static_cast< int >(cv::Matx< short,3,1 >::shortdim)));
SWIG_Python_SetConstant(d, "_Vec_short_3_channels",SWIG_From_int(static_cast< int >(cv::Vec< short,3 >::channels)));
SWIG_Python_SetConstant(d, "_DataType_Vec_short_3_generic_type",SWIG_From_int(static_cast< int >(cv::DataType< cv::Vec< short,3 > >::generic_type)));
SWIG_Python_SetConstant(d, "_DataType_Vec_short_3_channels",SWIG_From_int(static_cast< int >(cv::DataType< cv::Vec< short,3 > >::channels)));
SWIG_Python_SetConstant(d, "_DataType_Vec_short_3_fmt",SWIG_From_int(static_cast< int >(cv::DataType< cv::Vec< short,3 > >::fmt)));
SWIG_Python_SetConstant(d, "_Matx_short_4_1_rows",SWIG_From_int(static_cast< int >(cv::Matx< short,4,1 >::rows)));
SWIG_Python_SetConstant(d, "_Matx_short_4_1_cols",SWIG_From_int(static_cast< int >(cv::Matx< short,4,1 >::cols)));
SWIG_Python_SetConstant(d, "_Matx_short_4_1_channels",SWIG_From_int(static_cast< int >(cv::Matx< short,4,1 >::channels)));
SWIG_Python_SetConstant(d, "_Matx_short_4_1_shortdim",SWIG_From_int(static_cast< int >(cv::Matx< short,4,1 >::shortdim)));
SWIG_Python_SetConstant(d, "_Vec_short_4_channels",SWIG_From_int(static_cast< int >(cv::Vec< short,4 >::channels)));
SWIG_Python_SetConstant(d, "_DataType_Vec_short_4_generic_type",SWIG_From_int(static_cast< int >(cv::DataType< cv::Vec< short,4 > >::generic_type)));
SWIG_Python_SetConstant(d, "_DataType_Vec_short_4_channels",SWIG_From_int(static_cast< int >(cv::DataType< cv::Vec< short,4 > >::channels)));
SWIG_Python_SetConstant(d, "_DataType_Vec_short_4_fmt",SWIG_From_int(static_cast< int >(cv::DataType< cv::Vec< short,4 > >::fmt)));
SWIG_Python_SetConstant(d, "_cv_numpy_sizeof_ushort_value",SWIG_From_int(static_cast< int >(cv::_SizeOf< ushort >::value)));
SWIG_Python_SetConstant(d, "_Matx_ushort_2_1_rows",SWIG_From_int(static_cast< int >(cv::Matx< ushort,2,1 >::rows)));
SWIG_Python_SetConstant(d, "_Matx_ushort_2_1_cols",SWIG_From_int(static_cast< int >(cv::Matx< ushort,2,1 >::cols)));
SWIG_Python_SetConstant(d, "_Matx_ushort_2_1_channels",SWIG_From_int(static_cast< int >(cv::Matx< ushort,2,1 >::channels)));
SWIG_Python_SetConstant(d, "_Matx_ushort_2_1_shortdim",SWIG_From_int(static_cast< int >(cv::Matx< ushort,2,1 >::shortdim)));
SWIG_Python_SetConstant(d, "_Vec_ushort_2_channels",SWIG_From_int(static_cast< int >(cv::Vec< ushort,2 >::channels)));
SWIG_Python_SetConstant(d, "_DataType_Vec_ushort_2_generic_type",SWIG_From_int(static_cast< int >(cv::DataType< cv::Vec< ushort,2 > >::generic_type)));
SWIG_Python_SetConstant(d, "_DataType_Vec_ushort_2_channels",SWIG_From_int(static_cast< int >(cv::DataType< cv::Vec< ushort,2 > >::channels)));
SWIG_Python_SetConstant(d, "_DataType_Vec_ushort_2_fmt",SWIG_From_int(static_cast< int >(cv::DataType< cv::Vec< ushort,2 > >::fmt)));
SWIG_Python_SetConstant(d, "_Matx_ushort_3_1_rows",SWIG_From_int(static_cast< int >(cv::Matx< ushort,3,1 >::rows)));
SWIG_Python_SetConstant(d, "_Matx_ushort_3_1_cols",SWIG_From_int(static_cast< int >(cv::Matx< ushort,3,1 >::cols)));
SWIG_Python_SetConstant(d, "_Matx_ushort_3_1_channels",SWIG_From_int(static_cast< int >(cv::Matx< ushort,3,1 >::channels)));
SWIG_Python_SetConstant(d, "_Matx_ushort_3_1_shortdim",SWIG_From_int(static_cast< int >(cv::Matx< ushort,3,1 >::shortdim)));
SWIG_Python_SetConstant(d, "_Vec_ushort_3_channels",SWIG_From_int(static_cast< int >(cv::Vec< ushort,3 >::channels)));
SWIG_Python_SetConstant(d, "_DataType_Vec_ushort_3_generic_type",SWIG_From_int(static_cast< int >(cv::DataType< cv::Vec< ushort,3 > >::generic_type)));
SWIG_Python_SetConstant(d, "_DataType_Vec_ushort_3_channels",SWIG_From_int(static_cast< int >(cv::DataType< cv::Vec< ushort,3 > >::channels)));
SWIG_Python_SetConstant(d, "_DataType_Vec_ushort_3_fmt",SWIG_From_int(static_cast< int >(cv::DataType< cv::Vec< ushort,3 > >::fmt)));
SWIG_Python_SetConstant(d, "_Matx_ushort_4_1_rows",SWIG_From_int(static_cast< int >(cv::Matx< ushort,4,1 >::rows)));
SWIG_Python_SetConstant(d, "_Matx_ushort_4_1_cols",SWIG_From_int(static_cast< int >(cv::Matx< ushort,4,1 >::cols)));
SWIG_Python_SetConstant(d, "_Matx_ushort_4_1_channels",SWIG_From_int(static_cast< int >(cv::Matx< ushort,4,1 >::channels)));
SWIG_Python_SetConstant(d, "_Matx_ushort_4_1_shortdim",SWIG_From_int(static_cast< int >(cv::Matx< ushort,4,1 >::shortdim)));
SWIG_Python_SetConstant(d, "_Vec_ushort_4_channels",SWIG_From_int(static_cast< int >(cv::Vec< ushort,4 >::channels)));
SWIG_Python_SetConstant(d, "_DataType_Vec_ushort_4_generic_type",SWIG_From_int(static_cast< int >(cv::DataType< cv::Vec< ushort,4 > >::generic_type)));
SWIG_Python_SetConstant(d, "_DataType_Vec_ushort_4_channels",SWIG_From_int(static_cast< int >(cv::DataType< cv::Vec< ushort,4 > >::channels)));
SWIG_Python_SetConstant(d, "_DataType_Vec_ushort_4_fmt",SWIG_From_int(static_cast< int >(cv::DataType< cv::Vec< ushort,4 > >::fmt)));
SWIG_Python_SetConstant(d, "_cv_numpy_sizeof_int_value",SWIG_From_int(static_cast< int >(cv::_SizeOf< int >::value)));
SWIG_Python_SetConstant(d, "_Matx_int_2_1_rows",SWIG_From_int(static_cast< int >(cv::Matx< int,2,1 >::rows)));
SWIG_Python_SetConstant(d, "_Matx_int_2_1_cols",SWIG_From_int(static_cast< int >(cv::Matx< int,2,1 >::cols)));
SWIG_Python_SetConstant(d, "_Matx_int_2_1_channels",SWIG_From_int(static_cast< int >(cv::Matx< int,2,1 >::channels)));
SWIG_Python_SetConstant(d, "_Matx_int_2_1_shortdim",SWIG_From_int(static_cast< int >(cv::Matx< int,2,1 >::shortdim)));
SWIG_Python_SetConstant(d, "_Vec_int_2_channels",SWIG_From_int(static_cast< int >(cv::Vec< int,2 >::channels)));
SWIG_Python_SetConstant(d, "_DataType_Vec_int_2_generic_type",SWIG_From_int(static_cast< int >(cv::DataType< cv::Vec< int,2 > >::generic_type)));
SWIG_Python_SetConstant(d, "_DataType_Vec_int_2_channels",SWIG_From_int(static_cast< int >(cv::DataType< cv::Vec< int,2 > >::channels)));
SWIG_Python_SetConstant(d, "_DataType_Vec_int_2_fmt",SWIG_From_int(static_cast< int >(cv::DataType< cv::Vec< int,2 > >::fmt)));
SWIG_Python_SetConstant(d, "_Matx_int_3_1_rows",SWIG_From_int(static_cast< int >(cv::Matx< int,3,1 >::rows)));
SWIG_Python_SetConstant(d, "_Matx_int_3_1_cols",SWIG_From_int(static_cast< int >(cv::Matx< int,3,1 >::cols)));
SWIG_Python_SetConstant(d, "_Matx_int_3_1_channels",SWIG_From_int(static_cast< int >(cv::Matx< int,3,1 >::channels)));
SWIG_Python_SetConstant(d, "_Matx_int_3_1_shortdim",SWIG_From_int(static_cast< int >(cv::Matx< int,3,1 >::shortdim)));
SWIG_Python_SetConstant(d, "_Vec_int_3_channels",SWIG_From_int(static_cast< int >(cv::Vec< int,3 >::channels)));
SWIG_Python_SetConstant(d, "_DataType_Vec_int_3_generic_type",SWIG_From_int(static_cast< int >(cv::DataType< cv::Vec< int,3 > >::generic_type)));
SWIG_Python_SetConstant(d, "_DataType_Vec_int_3_channels",SWIG_From_int(static_cast< int >(cv::DataType< cv::Vec< int,3 > >::channels)));
SWIG_Python_SetConstant(d, "_DataType_Vec_int_3_fmt",SWIG_From_int(static_cast< int >(cv::DataType< cv::Vec< int,3 > >::fmt)));
SWIG_Python_SetConstant(d, "_Matx_int_4_1_rows",SWIG_From_int(static_cast< int >(cv::Matx< int,4,1 >::rows)));
SWIG_Python_SetConstant(d, "_Matx_int_4_1_cols",SWIG_From_int(static_cast< int >(cv::Matx< int,4,1 >::cols)));
SWIG_Python_SetConstant(d, "_Matx_int_4_1_channels",SWIG_From_int(static_cast< int >(cv::Matx< int,4,1 >::channels)));
SWIG_Python_SetConstant(d, "_Matx_int_4_1_shortdim",SWIG_From_int(static_cast< int >(cv::Matx< int,4,1 >::shortdim)));
SWIG_Python_SetConstant(d, "_Vec_int_4_channels",SWIG_From_int(static_cast< int >(cv::Vec< int,4 >::channels)));
SWIG_Python_SetConstant(d, "_DataType_Vec_int_4_generic_type",SWIG_From_int(static_cast< int >(cv::DataType< cv::Vec< int,4 > >::generic_type)));
SWIG_Python_SetConstant(d, "_DataType_Vec_int_4_channels",SWIG_From_int(static_cast< int >(cv::DataType< cv::Vec< int,4 > >::channels)));
SWIG_Python_SetConstant(d, "_DataType_Vec_int_4_fmt",SWIG_From_int(static_cast< int >(cv::DataType< cv::Vec< int,4 > >::fmt)));
SWIG_Python_SetConstant(d, "_Matx_int_6_1_rows",SWIG_From_int(static_cast< int >(cv::Matx< int,6,1 >::rows)));
SWIG_Python_SetConstant(d, "_Matx_int_6_1_cols",SWIG_From_int(static_cast< int >(cv::Matx< int,6,1 >::cols)));
SWIG_Python_SetConstant(d, "_Matx_int_6_1_channels",SWIG_From_int(static_cast< int >(cv::Matx< int,6,1 >::channels)));
SWIG_Python_SetConstant(d, "_Matx_int_6_1_shortdim",SWIG_From_int(static_cast< int >(cv::Matx< int,6,1 >::shortdim)));
SWIG_Python_SetConstant(d, "_Vec_int_6_channels",SWIG_From_int(static_cast< int >(cv::Vec< int,6 >::channels)));
SWIG_Python_SetConstant(d, "_DataType_Vec_int_6_generic_type",SWIG_From_int(static_cast< int >(cv::DataType< cv::Vec< int,6 > >::generic_type)));
SWIG_Python_SetConstant(d, "_DataType_Vec_int_6_channels",SWIG_From_int(static_cast< int >(cv::DataType< cv::Vec< int,6 > >::channels)));
SWIG_Python_SetConstant(d, "_DataType_Vec_int_6_fmt",SWIG_From_int(static_cast< int >(cv::DataType< cv::Vec< int,6 > >::fmt)));
SWIG_Python_SetConstant(d, "_Matx_int_8_1_rows",SWIG_From_int(static_cast< int >(cv::Matx< int,8,1 >::rows)));
SWIG_Python_SetConstant(d, "_Matx_int_8_1_cols",SWIG_From_int(static_cast< int >(cv::Matx< int,8,1 >::cols)));
SWIG_Python_SetConstant(d, "_Matx_int_8_1_channels",SWIG_From_int(static_cast< int >(cv::Matx< int,8,1 >::channels)));
SWIG_Python_SetConstant(d, "_Matx_int_8_1_shortdim",SWIG_From_int(static_cast< int >(cv::Matx< int,8,1 >::shortdim)));
SWIG_Python_SetConstant(d, "_Vec_int_8_channels",SWIG_From_int(static_cast< int >(cv::Vec< int,8 >::channels)));
SWIG_Python_SetConstant(d, "_DataType_Vec_int_8_generic_type",SWIG_From_int(static_cast< int >(cv::DataType< cv::Vec< int,8 > >::generic_type)));
SWIG_Python_SetConstant(d, "_DataType_Vec_int_8_channels",SWIG_From_int(static_cast< int >(cv::DataType< cv::Vec< int,8 > >::channels)));
SWIG_Python_SetConstant(d, "_DataType_Vec_int_8_fmt",SWIG_From_int(static_cast< int >(cv::DataType< cv::Vec< int,8 > >::fmt)));
SWIG_Python_SetConstant(d, "_cv_numpy_sizeof_float_value",SWIG_From_int(static_cast< int >(cv::_SizeOf< float >::value)));
SWIG_Python_SetConstant(d, "_Matx_float_2_1_rows",SWIG_From_int(static_cast< int >(cv::Matx< float,2,1 >::rows)));
SWIG_Python_SetConstant(d, "_Matx_float_2_1_cols",SWIG_From_int(static_cast< int >(cv::Matx< float,2,1 >::cols)));
SWIG_Python_SetConstant(d, "_Matx_float_2_1_channels",SWIG_From_int(static_cast< int >(cv::Matx< float,2,1 >::channels)));
SWIG_Python_SetConstant(d, "_Matx_float_2_1_shortdim",SWIG_From_int(static_cast< int >(cv::Matx< float,2,1 >::shortdim)));
SWIG_Python_SetConstant(d, "_Vec_float_2_channels",SWIG_From_int(static_cast< int >(cv::Vec< float,2 >::channels)));
SWIG_Python_SetConstant(d, "_DataType_Vec_float_2_generic_type",SWIG_From_int(static_cast< int >(cv::DataType< cv::Vec< float,2 > >::generic_type)));
SWIG_Python_SetConstant(d, "_DataType_Vec_float_2_channels",SWIG_From_int(static_cast< int >(cv::DataType< cv::Vec< float,2 > >::channels)));
SWIG_Python_SetConstant(d, "_DataType_Vec_float_2_fmt",SWIG_From_int(static_cast< int >(cv::DataType< cv::Vec< float,2 > >::fmt)));
SWIG_Python_SetConstant(d, "_Matx_float_3_1_rows",SWIG_From_int(static_cast< int >(cv::Matx< float,3,1 >::rows)));
SWIG_Python_SetConstant(d, "_Matx_float_3_1_cols",SWIG_From_int(static_cast< int >(cv::Matx< float,3,1 >::cols)));
SWIG_Python_SetConstant(d, "_Matx_float_3_1_channels",SWIG_From_int(static_cast< int >(cv::Matx< float,3,1 >::channels)));
SWIG_Python_SetConstant(d, "_Matx_float_3_1_shortdim",SWIG_From_int(static_cast< int >(cv::Matx< float,3,1 >::shortdim)));
SWIG_Python_SetConstant(d, "_Vec_float_3_channels",SWIG_From_int(static_cast< int >(cv::Vec< float,3 >::channels)));
SWIG_Python_SetConstant(d, "_DataType_Vec_float_3_generic_type",SWIG_From_int(static_cast< int >(cv::DataType< cv::Vec< float,3 > >::generic_type)));
SWIG_Python_SetConstant(d, "_DataType_Vec_float_3_channels",SWIG_From_int(static_cast< int >(cv::DataType< cv::Vec< float,3 > >::channels)));
SWIG_Python_SetConstant(d, "_DataType_Vec_float_3_fmt",SWIG_From_int(static_cast< int >(cv::DataType< cv::Vec< float,3 > >::fmt)));
SWIG_Python_SetConstant(d, "_Matx_float_4_1_rows",SWIG_From_int(static_cast< int >(cv::Matx< float,4,1 >::rows)));
SWIG_Python_SetConstant(d, "_Matx_float_4_1_cols",SWIG_From_int(static_cast< int >(cv::Matx< float,4,1 >::cols)));
SWIG_Python_SetConstant(d, "_Matx_float_4_1_channels",SWIG_From_int(static_cast< int >(cv::Matx< float,4,1 >::channels)));
SWIG_Python_SetConstant(d, "_Matx_float_4_1_shortdim",SWIG_From_int(static_cast< int >(cv::Matx< float,4,1 >::shortdim)));
SWIG_Python_SetConstant(d, "_Vec_float_4_channels",SWIG_From_int(static_cast< int >(cv::Vec< float,4 >::channels)));
SWIG_Python_SetConstant(d, "_DataType_Vec_float_4_generic_type",SWIG_From_int(static_cast< int >(cv::DataType< cv::Vec< float,4 > >::generic_type)));
SWIG_Python_SetConstant(d, "_DataType_Vec_float_4_channels",SWIG_From_int(static_cast< int >(cv::DataType< cv::Vec< float,4 > >::channels)));
SWIG_Python_SetConstant(d, "_DataType_Vec_float_4_fmt",SWIG_From_int(static_cast< int >(cv::DataType< cv::Vec< float,4 > >::fmt)));
SWIG_Python_SetConstant(d, "_Matx_float_6_1_rows",SWIG_From_int(static_cast< int >(cv::Matx< float,6,1 >::rows)));
SWIG_Python_SetConstant(d, "_Matx_float_6_1_cols",SWIG_From_int(static_cast< int >(cv::Matx< float,6,1 >::cols)));
SWIG_Python_SetConstant(d, "_Matx_float_6_1_channels",SWIG_From_int(static_cast< int >(cv::Matx< float,6,1 >::channels)));
SWIG_Python_SetConstant(d, "_Matx_float_6_1_shortdim",SWIG_From_int(static_cast< int >(cv::Matx< float,6,1 >::shortdim)));
SWIG_Python_SetConstant(d, "_Vec_float_6_channels",SWIG_From_int(static_cast< int >(cv::Vec< float,6 >::channels)));
SWIG_Python_SetConstant(d, "_DataType_Vec_float_6_generic_type",SWIG_From_int(static_cast< int >(cv::DataType< cv::Vec< float,6 > >::generic_type)));
SWIG_Python_SetConstant(d, "_DataType_Vec_float_6_channels",SWIG_From_int(static_cast< int >(cv::DataType< cv::Vec< float,6 > >::channels)));
SWIG_Python_SetConstant(d, "_DataType_Vec_float_6_fmt",SWIG_From_int(static_cast< int >(cv::DataType< cv::Vec< float,6 > >::fmt)));
SWIG_Python_SetConstant(d, "_cv_numpy_sizeof_double_value",SWIG_From_int(static_cast< int >(cv::_SizeOf< double >::value)));
SWIG_Python_SetConstant(d, "_Matx_double_2_1_rows",SWIG_From_int(static_cast< int >(cv::Matx< double,2,1 >::rows)));
SWIG_Python_SetConstant(d, "_Matx_double_2_1_cols",SWIG_From_int(static_cast< int >(cv::Matx< double,2,1 >::cols)));
SWIG_Python_SetConstant(d, "_Matx_double_2_1_channels",SWIG_From_int(static_cast< int >(cv::Matx< double,2,1 >::channels)));
SWIG_Python_SetConstant(d, "_Matx_double_2_1_shortdim",SWIG_From_int(static_cast< int >(cv::Matx< double,2,1 >::shortdim)));
SWIG_Python_SetConstant(d, "_Vec_double_2_channels",SWIG_From_int(static_cast< int >(cv::Vec< double,2 >::channels)));
SWIG_Python_SetConstant(d, "_DataType_Vec_double_2_generic_type",SWIG_From_int(static_cast< int >(cv::DataType< cv::Vec< double,2 > >::generic_type)));
SWIG_Python_SetConstant(d, "_DataType_Vec_double_2_channels",SWIG_From_int(static_cast< int >(cv::DataType< cv::Vec< double,2 > >::channels)));
SWIG_Python_SetConstant(d, "_DataType_Vec_double_2_fmt",SWIG_From_int(static_cast< int >(cv::DataType< cv::Vec< double,2 > >::fmt)));
SWIG_Python_SetConstant(d, "_Matx_double_3_1_rows",SWIG_From_int(static_cast< int >(cv::Matx< double,3,1 >::rows)));
SWIG_Python_SetConstant(d, "_Matx_double_3_1_cols",SWIG_From_int(static_cast< int >(cv::Matx< double,3,1 >::cols)));
SWIG_Python_SetConstant(d, "_Matx_double_3_1_channels",SWIG_From_int(static_cast< int >(cv::Matx< double,3,1 >::channels)));
SWIG_Python_SetConstant(d, "_Matx_double_3_1_shortdim",SWIG_From_int(static_cast< int >(cv::Matx< double,3,1 >::shortdim)));
SWIG_Python_SetConstant(d, "_Vec_double_3_channels",SWIG_From_int(static_cast< int >(cv::Vec< double,3 >::channels)));
SWIG_Python_SetConstant(d, "_DataType_Vec_double_3_generic_type",SWIG_From_int(static_cast< int >(cv::DataType< cv::Vec< double,3 > >::generic_type)));
SWIG_Python_SetConstant(d, "_DataType_Vec_double_3_channels",SWIG_From_int(static_cast< int >(cv::DataType< cv::Vec< double,3 > >::channels)));
SWIG_Python_SetConstant(d, "_DataType_Vec_double_3_fmt",SWIG_From_int(static_cast< int >(cv::DataType< cv::Vec< double,3 > >::fmt)));
SWIG_Python_SetConstant(d, "_Matx_double_4_1_rows",SWIG_From_int(static_cast< int >(cv::Matx< double,4,1 >::rows)));
SWIG_Python_SetConstant(d, "_Matx_double_4_1_cols",SWIG_From_int(static_cast< int >(cv::Matx< double,4,1 >::cols)));
SWIG_Python_SetConstant(d, "_Matx_double_4_1_channels",SWIG_From_int(static_cast< int >(cv::Matx< double,4,1 >::channels)));
SWIG_Python_SetConstant(d, "_Matx_double_4_1_shortdim",SWIG_From_int(static_cast< int >(cv::Matx< double,4,1 >::shortdim)));
SWIG_Python_SetConstant(d, "_Vec_double_4_channels",SWIG_From_int(static_cast< int >(cv::Vec< double,4 >::channels)));
SWIG_Python_SetConstant(d, "_DataType_Vec_double_4_generic_type",SWIG_From_int(static_cast< int >(cv::DataType< cv::Vec< double,4 > >::generic_type)));
SWIG_Python_SetConstant(d, "_DataType_Vec_double_4_channels",SWIG_From_int(static_cast< int >(cv::DataType< cv::Vec< double,4 > >::channels)));
SWIG_Python_SetConstant(d, "_DataType_Vec_double_4_fmt",SWIG_From_int(static_cast< int >(cv::DataType< cv::Vec< double,4 > >::fmt)));
SWIG_Python_SetConstant(d, "_Matx_double_6_1_rows",SWIG_From_int(static_cast< int >(cv::Matx< double,6,1 >::rows)));
SWIG_Python_SetConstant(d, "_Matx_double_6_1_cols",SWIG_From_int(static_cast< int >(cv::Matx< double,6,1 >::cols)));
SWIG_Python_SetConstant(d, "_Matx_double_6_1_channels",SWIG_From_int(static_cast< int >(cv::Matx< double,6,1 >::channels)));
SWIG_Python_SetConstant(d, "_Matx_double_6_1_shortdim",SWIG_From_int(static_cast< int >(cv::Matx< double,6,1 >::shortdim)));
SWIG_Python_SetConstant(d, "_Vec_double_6_channels",SWIG_From_int(static_cast< int >(cv::Vec< double,6 >::channels)));
SWIG_Python_SetConstant(d, "_DataType_Vec_double_6_generic_type",SWIG_From_int(static_cast< int >(cv::DataType< cv::Vec< double,6 > >::generic_type)));
SWIG_Python_SetConstant(d, "_DataType_Vec_double_6_channels",SWIG_From_int(static_cast< int >(cv::DataType< cv::Vec< double,6 > >::channels)));
SWIG_Python_SetConstant(d, "_DataType_Vec_double_6_fmt",SWIG_From_int(static_cast< int >(cv::DataType< cv::Vec< double,6 > >::fmt)));
PyDict_SetItemString(md,(char*)"cvar", SWIG_globals());
SWIG_addvarlink(SWIG_globals(),(char*)"KCFTracker_pCmDev",Swig_var_KCFTracker_pCmDev_get, Swig_var_KCFTracker_pCmDev_set);
#if PY_VERSION_HEX >= 0x03000000
return m;
#else
return;
#endif
}
| [
"xiang092@gmail.com"
] | xiang092@gmail.com |
c3faf2e25403aad84ebcb09337a66e761791e0f1 | 9c9cc2acbd290b3d4f2c1c1e5af7280b25c69eaa | /SOB1/SOB1/ReadFile.h | b559064b28ec2390469a1db455116227e9f31023 | [] | no_license | fudalejt/AssertionCpp | 0cd7171c50031763e27b5fe1bf7123f1c94bdeaa | 6370944047493f37eff88f2c35f6f3f32d14405a | refs/heads/master | 2021-01-20T07:32:07.421926 | 2017-05-02T10:48:25 | 2017-05-02T10:48:25 | 90,011,085 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,087 | h | #pragma once
#include <string>
#include <fstream>
#include <iostream>
#include <sstream>
#include<cassert>
#include "Queue.h"
template<class T>
T stringToValue(string str) {
istringstream iss(str);
T value;
iss >> value;
return value;
}
template <typename Type>
class ReadFile
{
public:
ReadFile(std::string path);
virtual ~ReadFile();
void readFile(string path, qu::Queue<Type> &queue, const Type min, const Type max);
private:
std::string path;
};
template <typename Type>
ReadFile<Type>::ReadFile(std::string path)
{
path = path;
}
template <typename Type>
ReadFile<Type>::~ReadFile()
{
}
template <typename Type>
void ReadFile<Type>::readFile(string path, qu::Queue<Type> &queue, const Type min, const Type max)
{
std::fstream file;
file.open(path, std::ios::in);
assert(file.good());
string s;
while (true)
{
file >> s;
if (!file.eof()) {
auto d = stringToValue<Type>(s);
QueueElement<Type> *newEl = new QueueElement<Type>(d);
assert(newEl);
bool flag = queue.addWithBoundary(newEl, min, max);
assert(flag);
}
else
break;
}
}
| [
"fudalejt@gmail.com"
] | fudalejt@gmail.com |
aeb8379a071480e1a7bfcce199ed510f30112ef2 | 74d1dd1b2fb76ee4a65ec86cda22ddd2cdc64883 | /libs/STLPort-4.0/stlport/old_hp/hashtable.h | 479ad003cc16e0691b9a61a29f6f2f444c31b707 | [
"LicenseRef-scancode-stlport-4.5",
"LicenseRef-scancode-unknown-license-reference"
] | permissive | haekb/nolf2-modernizer | f9d966d7b9660610b47ea7618c4d53507b17adc4 | 75b2e715f804e10f1380e1c7bdb43664db61a01b | refs/heads/master | 2023-05-11T00:06:00.516030 | 2020-12-24T03:59:45 | 2020-12-24T03:59:45 | 207,464,324 | 30 | 4 | null | 2023-04-29T04:36:51 | 2019-09-10T04:20:07 | C++ | UTF-8 | C++ | false | false | 1,702 | h | /*
* Copyright (c) 1994
* Hewlett-Packard Company
*
* Copyright (c) 1996,1997
* Silicon Graphics Computer Systems, Inc.
*
* Copyright (c) 1997
* Moscow Center for SPARC Technology
*
* Copyright (c) 1999
* Boris Fomitchev
*
* This material is provided "as is", with absolutely no warranty expressed
* or implied. Any use is at your own risk.
*
* Permission to use or copy this software for any purpose is hereby granted
* without fee, provided the above notices are retained on all copies.
* Permission to modify the code and to distribute modified code is granted,
* provided the above notices are retained, and a notice that the code was
* modified is included with the above copyright notice.
*
*/
/* NOTE: This is an internal header file, included by other STL headers.
* You should not attempt to use it directly.
*/
#ifndef __SGI_STL_HASHTABLE_H
#define __SGI_STL_HASHTABLE_H
# ifndef __STL_OUTERMOST_HEADER_ID
# define __STL_OUTERMOST_HEADER_ID 0xa011
# include <stl/_prolog.h>
# endif
#ifndef __SGI_STL_ALGO_H
#include <algo.h>
#endif
#ifndef __SGI_STL_ALLOC_H
#include <alloc.h>
#endif
#ifndef __SGI_STL_VECTOR_H
#include <vector.h>
#endif
#ifndef __SGI_STL_HASH_FUN_H
#include <stl/_hash_fun.h>
#endif
#ifndef __SGI_STL_INTERNAL_HASHTABLE_H
#include <stl/_hashtable.h>
#endif
#ifdef __STL_USE_NAMESPACES
# ifdef __STL_BROKEN_USING_DIRECTIVE
using namespace STLPORT;
# else
using __STLPORT_STD::hash;
using STLPORT::hashtable;
# endif
#endif /* __STL_USE_NAMESPACES */
# if (__STL_OUTERMOST_HEADER_ID == 0xa011)
# include <stl/_epilog.h>
# undef __STL_OUTERMOST_HEADER_ID
# endif
#endif /* __SGI_STL_HASHTABLE_H */
// Local Variables:
// mode:C++
// End:
| [
"haekbreen@gmail.com"
] | haekbreen@gmail.com |
7071d023907b05dc1d5e3eafba0bc4e764c1d4b4 | 3503da903c40b703035ec0a9bcb7a63a0038ca2f | /EX_4/Mutexes3.cc | 070e27c7c885d6a976dba0319e84dfdd693cdf44 | [] | no_license | TheMopKingDom/NC358_OS_EX | 3d4b2d24a7437cde34557d8cc12c63635bb52548 | 719ec10b6106b7b7f16972234ecdb36cfca7aaa7 | refs/heads/master | 2020-05-20T20:53:05.109489 | 2019-05-16T03:47:59 | 2019-05-16T03:47:59 | 185,749,818 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,150 | cc | // thread0.c
#include <pthread.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/wait.h>
#define N 3
#define MAXSize 10
void *min_thread(void *arg)
{ int *test = (int*)arg;
int min=test[0];
for (int i=0; i<MAXSize ; i++){
if (test[i] < min){
min = test[i];
}
}
//printf("Min number is : %d\n", min);
static int successmin;
successmin = min;
pthread_exit((void *)&successmin);
}
void *max_thread(void *arg)
{ int *test = (int*)arg;
int max=test[0];
for (int i=0; i< MAXSize ; i++){
if (test[i] > max){
max = test[i];
}
}
//printf("Max number is : %d\n", max);
static int successmax;
successmax = max;
pthread_exit((void *)&successmax);
}
void *Avg_thread(void *arg){
int *test = (int*)arg;
int avg=0;
for (int i=0; i< MAXSize ; i++){
avg += test[i];
}
avg = avg/MAXSize ;
//printf("Avg number is : %d\n", avg);
static int successavg;
successavg = avg;
pthread_exit((void *)&successavg);
}
int main(int argc, char *argv[])
{
srand(time(NULL));
int random_number[MAXSize];
void *min,*max,*avg;
for(int i= 0;i<MAXSize;i++){
random_number[i] = rand() % 100 + 1;
printf("random_number %d : %d\n",(i+1),random_number[i] );
}
pthread_t my_thread[N];
pthread_create(&my_thread[0], NULL, min_thread, (void*)&random_number);
pthread_create(&my_thread[1], NULL, max_thread, (void*)&random_number);
pthread_create(&my_thread[2], NULL, Avg_thread, (void*)&random_number);
pthread_join(my_thread[0], &min);
pthread_join(my_thread[1], &max);
pthread_join(my_thread[2], &avg);
printf("Min of main : %d\n",*(int *)min);
printf("Max of main : %d\n",*(int *)max);
printf("Avg of main : %d\n",*(int *)avg);
return 0;
}
| [
"noreply@github.com"
] | TheMopKingDom.noreply@github.com |
542bcb75bb55975b906e53dd5bd0a16d14aced0e | 3a13b93b605cd3481b6ec54202d253af2a0ad854 | /FN/SDK/FN_SelfItemTIleWidget_classes.hpp | 60a37853891200f2ada69a3621c881ffffd02af0 | [] | no_license | antiwar3/WXY-SDK | 12bc929c3371756fb8eac2f9aba6ffb53be17109 | 20c2e89189fbcdd40c407c799d71ff20da096584 | refs/heads/master | 2020-04-15T10:19:42.493604 | 2019-01-08T07:39:48 | 2019-01-08T07:39:48 | 164,591,515 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 1,571 | hpp | #pragma once
// Fortnite (1.6.4) SDK
#ifdef _MSC_VER
#pragma pack(push, 0x8)
#endif
namespace SDK
{
//---------------------------------------------------------------------------
//Classes
//---------------------------------------------------------------------------
// WidgetBlueprintGeneratedClass SelfItemTIleWidget.SelfItemTIleWidget_C
// 0x0010 (0x0218 - 0x0208)
class USelfItemTIleWidget_C : public UUserWidget
{
public:
struct FPointerToUberGraphFrame UberGraphFrame; // 0x0208(0x0008) (ZeroConstructor, Transient, DuplicateTransient)
class UTextBlock* BoxName; // 0x0210(0x0008) (BlueprintVisible, ExportObject, ZeroConstructor, InstancedReference, IsPlainOldData, RepSkip, RepNotify, Interp, NonTransactional, EditorOnly, NoDestructor, AutoWeak, ContainsInstancedReference, AssetRegistrySearchable, SimpleDisplay, AdvancedDisplay, Protected, BlueprintCallable, BlueprintAuthorityOnly, TextExportTransient, NonPIEDuplicateTransient, ExposeOnSpawn, PersistentInstance, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic, NativeAccessSpecifierProtected, NativeAccessSpecifierPrivate)
static UClass* StaticClass()
{
static auto ptr = UObject::FindClass("WidgetBlueprintGeneratedClass SelfItemTIleWidget.SelfItemTIleWidget_C");
return ptr;
}
void SetName(const struct FString& Name);
void ExecuteUbergraph_SelfItemTIleWidget(int EntryPoint);
};
}
#ifdef _MSC_VER
#pragma pack(pop)
#endif
| [
"237213@qq.com"
] | 237213@qq.com |
ea977cf34120e03c14e67ee05a4361a19aa12337 | d48139ef3f4deec12fc2861d1788115243dfb553 | /show.cpp | aaa88ca3d3aa8215826447b7ce131c9b081afa6f | [] | no_license | teleger/QtTestImage | a9784088ceafe02f30baecf39371f900230a2d63 | 5fc88c0f9dc73fa922251ef3ac99a89a0d126701 | refs/heads/master | 2022-12-04T03:29:55.805360 | 2020-08-20T04:20:45 | 2020-08-20T04:20:45 | 288,904,837 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 311 | cpp | #include "show.h"
showImage::showImage(QWidget *parent):QWidget(parent){
show1.load("/home/work/tensorflow.jpg");//文件路径
}
showImage::~showImage(){
}
void showImage::paintEvent(QPaintEvent *e)
{
QPainter pp(this);
QRect Temp(0,0,this->width(),this->height());
pp.drawImage(Temp,show1);
}
| [
"459103831@qq.com"
] | 459103831@qq.com |
36b56d404496d981e76a002b28935fd44b714f84 | 53352a7770ff7a41a5760835cbe60e7bae58fa0b | /Ray Shaper/source/objects/ReflectionTile.h | 335e9d914d4bcfd75699b10d368422998b676959 | [] | no_license | antjowie/Ray-Shaper | b8d15f42982c06466d5e973ec43023be9cd18a45 | 23aae22ea617c20462e93259efbb92b2bcf74f23 | refs/heads/master | 2021-08-10T17:38:23.372970 | 2021-05-21T15:18:00 | 2021-05-21T15:18:00 | 116,961,294 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 837 | h | #pragma once
#include "Object.h"
class ReflectionTile : public Object
{
private:
const int m_id;
public:
const enum Direction
{
// Special direction for the reflector, the non direction
// Used to omit loading
Reflector_Non = 0,
RightUp,
RightDown,
LeftDown,
LeftUp,
Up,
Down,
Left,
Right,
// Used to loop around
Capacity
}m_direction;
bool isGrabbed{ false };
const bool canMove{ true };
virtual void update(const float elapsedTime) override;
virtual void move(const sf::Vector2f &movement) override;
// Get the edges, used by laser to calculate acurate hitboxes
virtual const std::vector<sf::Vector2f> getVertices() const;
virtual std::map<std::string, std::string> getSaveData() const override;
ReflectionTile(ObjectManager &objectManager, const int id, const sf::Vector2f &position);
}; | [
"angelo05rettob@gmail.com"
] | angelo05rettob@gmail.com |
8b26b83821b4048fee0238c0c95a693684793983 | 9208443ce40b92ba24d6df91dd56a1356b26bbf0 | /src/atr.cpp | 14c245e809bc8fe64536d74da618e53c1d689ab3 | [] | no_license | mussonero/quanttools | 8e84a0a96d5f48d375f065e6e738051a9a16790e | 23db968a591c50077f4f363e075125ca1c20a1ab | refs/heads/master | 2020-12-06T01:30:56.989809 | 2020-01-07T10:38:18 | 2020-01-07T10:38:18 | 232,302,108 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,192 | cpp | // Copyright (C) 2018 Ernesto Fernández
//
// This file is part of QuantTools.
//
// QuantTools 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.
//
// QuantTools 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 QuantTools. If not, see <http://www.gnu.org/licenses/>.
#include "../inst/include/Indicators/Atr.h"
#include <string>
//' Average True Range
//'
//' @name atr
//' @param x \code{high, low, close} data.frame
//' @param n window size
//' @family technical indicators
//' @return data.table with columns \code{tr, atr, trueHigh, trueLow}
//' @description Average True Rangeis a measure of volatility of a High-Low-Close series.
//' @export
// [[Rcpp::export]]
Rcpp::List atr( Rcpp::DataFrame x, size_t n ) {
Rcpp::DataFrame hlc = Rcpp::as< Rcpp::DataFrame >( x );
Rcpp::StringVector names = hlc.attr( "names" );
bool hasHigh = std::find( names.begin(), names.end(), "high" ) != names.end();
bool hasLow = std::find( names.begin(), names.end(), "low" ) != names.end();
bool hasClose = std::find( names.begin(), names.end(), "close" ) != names.end();
if( !hasHigh ) throw std::invalid_argument( "ticks must contain 'high' column" );
if( !hasLow ) throw std::invalid_argument( "ticks must contain 'low' column" );
if( !hasClose ) throw std::invalid_argument( "ticks must contain 'close' column" );
Rcpp::NumericVector highs = hlc[ "high" ];
Rcpp::NumericVector lows = hlc[ "low" ];
Rcpp::NumericVector closes = hlc[ "close" ];
Atr<Candle> atr( n );
for( auto i = 0; i < highs.size(); i++ ) {
Candle candle( 1 );
candle.low = lows [i];
candle.high = highs [i];
candle.close = closes[i];
atr.Add( candle );
}
return atr.GetHistory();
}
//' @name atr
| [
"mussonero@gmail.com"
] | mussonero@gmail.com |
d8e8065d8be50fff6396ec8bc54dde1dd28c3e1f | 2a4304a7092ef8853ef167eb6f367ca9af9c5476 | /Source/SketchBot_Complete_jk/clear_traversed_path.cpp | 2b86cb3dc04f1ab482e8d8c21a6ac1af4f139ef8 | [] | no_license | ssaurabh41/Sketch-Bot | 80939f0147b445663675fe46eb97153e2ddd2f0f | 0947b8a8b5897ec33d1c36a61a9ea02a7f5ad2d2 | refs/heads/master | 2021-05-29T03:01:42.719980 | 2015-04-19T15:03:38 | 2015-04-19T15:03:38 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,580 | cpp | #include "global_variables.h"
#include "Points.h"
#include <opencv2/core/core.hpp>
#include <opencv/cv.h>
using namespace std;
using namespace cv;
//makes a 3x3 box around every pixel present in path white in the image entered.
//this is to remove excess pixels which might remain after a path is generated
/*
say image is like this:
*
**
*
then as the path is made, it becomes -> x -> x -> x
** x* x*
* * x
so one of the * has remained. It doesnt belong to a different path and so must be deleted
*/
void clear_traversed_path(Mat image_only_borders, vector<Points> &path)
{
vector<Points>::iterator it=path.begin();
for(it=path.begin()+1;it!=path.end()-1;++it)
{
for(int x=it->x-1;x<=it->x+1;x++)
for(int y=it->y-1;y<=it->y+1;y++)
{
bool isAtStart=0;
for(int a=(path.begin()->x)-1;a<=(path.begin()->x)+1;a++)
{
for(int b=(path.begin()->y)-1;b<=(path.begin()->y)+1;b++)
if(x==a && y==b)
{
isAtStart=1;
break;
}
if(isAtStart) break;
}
if(!isAtStart) image_only_borders.at<uchar>(y,x)=255;
}
}
}
//check for whether point is around start point
| [
"ssaurabh41@gmail.com"
] | ssaurabh41@gmail.com |
509e0550410ae749362ae17e0d900d8974a9f5b8 | 35bc9ffa534ce5597fe8d78b76b5ec136fea9008 | /src/MeteoriteGUI.cpp | f5a8577b527ea6a5a11181dcb5cf8ce4311a8265 | [] | no_license | EUA/Meteorite | 599f91fbafdbaeec746ea1445c9c96c692e2303c | 73e8b08b2f05b1c4c823a9777ffd3d536d14c6af | refs/heads/master | 2021-01-19T20:26:38.320024 | 2013-02-14T02:55:53 | 2013-02-14T02:55:53 | 83,752,227 | 6 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 2,541 | cpp | ///////////////////////////////////////////////////////////////////////////
// C++ code generated with wxFormBuilder (version Apr 17 2008)
// http://www.wxformbuilder.org/
//
// PLEASE DO "NOT" EDIT THIS FILE!
///////////////////////////////////////////////////////////////////////////
#include "wx/wxprec.h"
#ifdef __BORLANDC__
#pragma hdrstop
#endif //__BORLANDC__
#ifndef WX_PRECOMP
#include <wx/wx.h>
#endif //WX_PRECOMP
#include "MeteoriteGUI.h"
///////////////////////////////////////////////////////////////////////////
MeteoriteGUI::MeteoriteGUI( wxWindow* parent, wxWindowID id, const wxString& title, const wxPoint& pos, const wxSize& size, long style ) : wxDialog( parent, id, title, pos, size, style )
{
this->SetSizeHints( wxDefaultSize, wxDefaultSize );
wxBoxSizer* bSizerMain;
bSizerMain = new wxBoxSizer( wxVERTICAL );
m_gauge = new wxGauge( this, wxID_ANY, 100, wxDefaultPosition, wxDefaultSize, wxGA_HORIZONTAL );
m_gauge->Hide();
bSizerMain->Add( m_gauge, 0, wxALL|wxEXPAND, 5 );
m_staticText = new wxStaticText( this, wxID_ANY, wxT("Drag and Drop Files"), wxDefaultPosition, wxDefaultSize, wxALIGN_CENTRE );
m_staticText->Wrap( -1 );
bSizerMain->Add( m_staticText, 0, wxALIGN_CENTER|wxALL, 5 );
m_bitmap_logo = new wxStaticBitmap( this, wxID_ANY, wxNullBitmap, wxDefaultPosition, wxDefaultSize, 0 );
bSizerMain->Add( m_bitmap_logo, 0, wxALL, 5 );
this->SetSizer( bSizerMain );
this->Layout();
bSizerMain->Fit( this );
// Connect Events
this->Connect( wxEVT_CLOSE_WINDOW, wxCloseEventHandler( MeteoriteGUI::OnClose ) );
this->Connect( wxEVT_RIGHT_DOWN, wxMouseEventHandler( MeteoriteGUI::OnMouseRight ) );
m_gauge->Connect( wxEVT_RIGHT_DOWN, wxMouseEventHandler( MeteoriteGUI::OnMouseRight ), NULL, this );
m_staticText->Connect( wxEVT_RIGHT_DOWN, wxMouseEventHandler( MeteoriteGUI::OnMouseRight ), NULL, this );
m_bitmap_logo->Connect( wxEVT_RIGHT_DOWN, wxMouseEventHandler( MeteoriteGUI::OnMouseRight ), NULL, this );
}
MeteoriteGUI::~MeteoriteGUI()
{
// Disconnect Events
this->Disconnect( wxEVT_CLOSE_WINDOW, wxCloseEventHandler( MeteoriteGUI::OnClose ) );
this->Disconnect( wxEVT_RIGHT_DOWN, wxMouseEventHandler( MeteoriteGUI::OnMouseRight ) );
m_gauge->Disconnect( wxEVT_RIGHT_DOWN, wxMouseEventHandler( MeteoriteGUI::OnMouseRight ), NULL, this );
m_staticText->Disconnect( wxEVT_RIGHT_DOWN, wxMouseEventHandler( MeteoriteGUI::OnMouseRight ), NULL, this );
m_bitmap_logo->Disconnect( wxEVT_RIGHT_DOWN, wxMouseEventHandler( MeteoriteGUI::OnMouseRight ), NULL, this );
}
| [
"erdem_ua@f02f1a5c-2511-4db8-bd4a-9f0cd9d69ea4"
] | erdem_ua@f02f1a5c-2511-4db8-bd4a-9f0cd9d69ea4 |
8a7719cd1c28f0c838b01658bf4fdbc7dd1c2b2a | a4bf7ef197edc81b1d15ae9c75397aec22f14850 | /allegro5/tutorial/fullscreen.cpp | 2ede5f1b8157d370953edb9fb0ed235c8aaad739 | [
"CC-BY-3.0"
] | permissive | anagorko/kinf | 2c48b43525907a61b66cddd46be4405eac908518 | 38c44fb6905f45da95405aa72bd979eb90cf1058 | refs/heads/master | 2020-04-12T06:35:45.396095 | 2017-12-31T19:47:07 | 2017-12-31T19:47:07 | 7,894,789 | 5 | 12 | null | 2017-03-24T12:58:21 | 2013-01-29T15:23:15 | C++ | UTF-8 | C++ | false | false | 603 | cpp | #include "allegro5/allegro.h"
#include "allegro5/allegro_image.h"
#include "allegro5/allegro_primitives.h"
int main(int argc, char** argv){
ALLEGRO_DISPLAY *display = NULL;
ALLEGRO_DISPLAY_MODE disp_data;
al_init(); // I'm not checking the return value for simplicity.
al_init_image_addon();
al_init_primitives_addon();
al_get_display_mode(al_get_num_display_modes() - 1, &disp_data);
al_set_new_display_flags(ALLEGRO_FULLSCREEN);
display = al_create_display(disp_data.width, disp_data.height);
al_rest(3);
al_destroy_display(display);
return 0;
}
| [
"amn@mimuw.edu.pl"
] | amn@mimuw.edu.pl |
f265a9c42d538db9dfd6b22d31e9504d998449e8 | c316e503a82bae36f17334136977e350b4aa9a80 | /Chapter05/unruh.cc | d79f7a88b4443ff605139fc7853b5ef31da23a1c | [] | no_license | philipdongfei/DiscoveringModernCPP | 18595565a871b466067d8a682f41231c21b71f96 | 54ab1c229d40d6a06f968fc6152773d27f260402 | refs/heads/master | 2022-12-12T01:54:02.479957 | 2020-08-25T02:15:44 | 2020-08-25T02:15:44 | 272,901,912 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 647 | cc | // Prime number computation by Erwin Unruh
template <int i> struct D { D(void *); operator int(); };
template <int p, int i> struct is_prime {
enum { prim = (p==2) || (p%i) && is_prime<(i>2?p:0), i-1> :: prim };
};
template <int i> struct Prime_print {
Prime_print<i-1> a;
enum { prim = is_prime<i, i-1>::prim };
void f() { D<i> d = prim ? 1 : 0; a.f(); }
};
template<> struct is_prime<0,0> { enum {prim=1}; };
template<> struct is_prime<0,1> { enum {prim=1}; };
template<> struct Prime_print<1> {
enum {prim=0};
void f() { D<1> d = prim ? 1 : 0; };
};
int main() {
Prime_print<18> a;
a.f();
return 0;
}
| [
"philip.dongfei@gmail.com"
] | philip.dongfei@gmail.com |
70c935143b943a361fa1138b3c2062bbf2a65051 | 96cfaaa771c2d83fc0729d8c65c4d4707235531a | /CondTools/CSC/interface/CSCFakeDBCrosstalkHandler.h | 2e40d6f3626a4734b06f74f9607402cdf280d244 | [] | no_license | khotilov/cmssw | a22a160023c7ce0e4d59d15ef1f1532d7227a586 | 7636f72278ee0796d0203ac113b492b39da33528 | refs/heads/master | 2021-01-15T18:51:30.061124 | 2013-04-20T17:18:07 | 2013-04-20T17:18:07 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 946 | h | #ifndef CSC_FAKEDBGAINS_SRC_IMPL_H
#define CSC_FAKEDBGAINS_SRC_IMPL_H
#include <vector>
#include <string>
#include <iostream>
#include <typeinfo>
#include "CondCore/PopCon/interface/PopConSourceHandler.h"
#include "CondFormats/CSCObjects/interface/CSCobject.h"
#include "CondFormats/DataRecord/interface/CSCDBCrosstalkRcd.h"
#include "FWCore/Framework/interface/ESHandle.h"
#include "FWCore/Framework/interface/Event.h"
#include "DataFormats/Common/interface/Handle.h"
#include "FWCore/Framework/interface/EventSetup.h"
#include "CondTools/CSC/interface/CSCFakeDBCrosstalk.h"
namespace popcon
{
class CSCFakeDBCrosstalkImpl : public popcon::PopConSourceHandler<CSCDBCrosstalk>
{
public:
void getNewObjects();
std::string id() const { return m_name;}
~CSCFakeDBCrosstalkImpl();
CSCFakeDBCrosstalkImpl(const edm::ParameterSet& pset);
private:
std::string m_name;
};
}
#endif
| [
"sha1-a5ceae9af4b986cf7f52071a8ae913361a62b84e@cern.ch"
] | sha1-a5ceae9af4b986cf7f52071a8ae913361a62b84e@cern.ch |
c539fd8eec19a29d9206bcc01de36281e41c8275 | 528dc610bb0513b255b613d6aaa0b59d4c9af9db | /Tool/RS232 Tool/Interface_V2.0 - 複製/Member.h | 5596029e37378b7e9f5869b508dc357dc3ae13bf | [] | no_license | hesitationer/3111 | 7b7e468de38950a1a357e16f643098630e33a68a | 4fba49c2c2a6a78f9b3c5a006df85e33cfeb8b96 | refs/heads/master | 2021-05-27T19:07:55.625866 | 2014-07-31T01:15:38 | 2014-07-31T01:15:46 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 552 | h | // Member.h: interface for the CMember class.
//
//////////////////////////////////////////////////////////////////////
#if !defined(AFX_MEMBER_H__4CDF129E_9D65_4351_93EA_339601AEC5D2__INCLUDED_)
#define AFX_MEMBER_H__4CDF129E_9D65_4351_93EA_339601AEC5D2__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
#include "ComInterface.h"
class CMember
{
public:
CMember();
virtual ~CMember();
public:
CInterface Com;
int Count;
int iValue;
};
#endif // !defined(AFX_MEMBER_H__4CDF129E_9D65_4351_93EA_339601AEC5D2__INCLUDED_)
| [
"harper@chroma.com.tw"
] | harper@chroma.com.tw |
7c0b39d5a6bacdcdb60a1ffedd784fc90ebf3954 | b219519f94e6c6782f641a5a9d2dcf22537fac3b | /normal/google/kickstart/2022_11_12/Magical_Well_Of_Lilies.cpp | b9fa1924766bd8dfbe1ecbeca4a8e5fe58f9d26a | [] | no_license | liangsheng/ACM | 71a37a85b13aa7680a095cf0710c50acb5457641 | 0e80385b51e622b2b97431ac650b8121ecd56e51 | refs/heads/master | 2023-06-01T06:37:51.727779 | 2023-05-14T03:16:18 | 2023-05-14T03:16:18 | 9,337,661 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,221 | cpp | #include <bits/stdc++.h>
using namespace std;
typedef long long LL;
int main() {
// ios::sync_with_stdio(false);
// cin.tie(0);
// clock_t startTime, endTime;
// startTime = clock();
int T, n = 100000, ans;
int dp[100001];
dp[1] = 1;
for (int i = 2; i <= n; i++) {
dp[i] = i;
for (int j = 1; j * 2 <= i; j++) {
int tmp = dp[j] + 4 + (i - j) / j * 2 + (i - j) % j;
dp[i] = min(dp[i], tmp);
}
}
// endTime = clock(); //计时结束
// cout << "The run time is: " <<(double)(endTime - startTime) / CLOCKS_PER_SEC << "s" << endl;
// for (int i = 1; i <= n; i++) cout << dp[i] << ", ";
cin >> T;
for (int cas = 1; cas <= T; cas++) {
cin >> n;
// vector<int> dp(n + 1, 0);
// dp[1] = 1;
// for (int i = 2; i <= n; i++) {
// dp[i] = i;
// for (int j = 1; j * 2 <= i; j++) {
// int tmp = dp[j] + 4 + (i - j) / j * 2 + (i - j) % j;
// dp[i] = min(dp[i], tmp);
// }
// cout << "i= " << i << ", dp[i]= " << dp[i] << '\n';
// }
cout << "Case #" << cas << ": " << dp[n] << '\n';
}
return 0;
} | [
"904491908@qq.com"
] | 904491908@qq.com |
d01bf8f7031e95d96e11f1b91f8b241955b46fb1 | c8b39acfd4a857dc15ed3375e0d93e75fa3f1f64 | /Engine/Source/ThirdParty/OpenSubdiv/3.0.2/opensubdiv/osd/cpuD3D11VertexBuffer.h | 8c6b2d19b85b1fffa9fe2c00db022ab1941189e5 | [
"MIT",
"LicenseRef-scancode-proprietary-license",
"LicenseRef-scancode-free-unknown",
"Apache-2.0"
] | permissive | windystrife/UnrealEngine_NVIDIAGameWorks | c3c7863083653caf1bc67d3ef104fb4b9f302e2a | b50e6338a7c5b26374d66306ebc7807541ff815e | refs/heads/4.18-GameWorks | 2023-03-11T02:50:08.471040 | 2022-01-13T20:50:29 | 2022-01-13T20:50:29 | 124,100,479 | 262 | 179 | MIT | 2022-12-16T05:36:38 | 2018-03-06T15:44:09 | C++ | UTF-8 | C++ | false | false | 3,187 | h | //
// Copyright 2013 Pixar
//
// Licensed under the Apache License, Version 2.0 (the "Apache License")
// with the following modification; you may not use this file except in
// compliance with the Apache License and the following modification to it:
// Section 6. Trademarks. is deleted and replaced with:
//
// 6. Trademarks. This License does not grant permission to use the trade
// names, trademarks, service marks, or product names of the Licensor
// and its affiliates, except as required to comply with Section 4(c) of
// the License and to reproduce the content of the NOTICE file.
//
// You may obtain a copy of the Apache License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the Apache License with the above modification is
// distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied. See the Apache License for the specific
// language governing permissions and limitations under the Apache License.
//
#ifndef OPENSUBDIV3_OSD_CPU_D3D11_VERTEX_BUFFER_H
#define OPENSUBDIV3_OSD_CPU_D3D11_VERTEX_BUFFER_H
#include "../version.h"
#include <cstddef>
struct ID3D11Buffer;
struct ID3D11Device;
struct ID3D11DeviceContext;
namespace OpenSubdiv {
namespace OPENSUBDIV_VERSION {
namespace Osd {
///
/// \brief Concrete vertex buffer class for Cpu subvision and DirectX drawing.
///
/// CpuD3D11VertexBuffer implements CpuVertexBufferInterface and
/// D3D11VertexBufferInterface.
///
/// An instance of this buffer class can be passed to CpuEvaluator.
///
class CpuD3D11VertexBuffer {
public:
/// Creator. Returns NULL if error.
static CpuD3D11VertexBuffer * Create(int numElements, int numVertices,
ID3D11DeviceContext *deviceContext);
/// Destructor.
virtual ~CpuD3D11VertexBuffer();
/// This method is meant to be used in client code in order to provide coarse
/// vertices data to Osd.
void UpdateData(const float *src, int startVertex, int numVertices,
void *deviceContext = NULL);
/// Returns how many elements defined in this vertex buffer.
int GetNumElements() const;
/// Returns how many vertices allocated in this vertex buffer.
int GetNumVertices() const;
/// Returns the address of CPU buffer.
float * BindCpuBuffer();
/// Returns the D3D11 buffer object.
ID3D11Buffer *BindD3D11Buffer(ID3D11DeviceContext *deviceContext);
/// Returns the D3D11 buffer object (for Osd::Mesh interface)
ID3D11Buffer *BindVBO(ID3D11DeviceContext *deviceContext) {
return BindD3D11Buffer(deviceContext);
}
protected:
/// Constructor.
CpuD3D11VertexBuffer(int numElements, int numVertices);
bool allocate(ID3D11Device *device);
private:
int _numElements;
int _numVertices;
ID3D11Buffer *_d3d11Buffer;
float *_cpuBuffer;
};
} // end namespace Osd
} // end namespace OPENSUBDIV_VERSION
using namespace OPENSUBDIV_VERSION;
} // end namespace OpenSubdiv
#endif // OPENSUBDIV3_OSD_CPU_D3D11_VERTEX_BUFFER_H
| [
"tungnt.rec@gmail.com"
] | tungnt.rec@gmail.com |
d977f4a38e0ab3c09fa4b4b8e5fba9ffc7ed441e | 4006cd74e5d67af70ac4336600832791988ac744 | /code_files/dab_monobit2.cpp | df46a4953f472bddf4d4e2d79ea9e10c17127fde | [] | no_license | sovist/Diehard-statistical-test-UI | aefc5c9a57be3a0719d1aa282733f0857cb41c95 | a7ad5310cf2d897735c6fd927d2419782a731b49 | refs/heads/master | 2021-01-19T00:13:27.505491 | 2015-03-21T18:51:09 | 2015-03-21T18:51:09 | 32,643,544 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,899 | cpp | /*
* ========================================================================
* $Id: sts_monobit.c 237 2006-08-23 01:33:46Z rgb $
*
* See copyright in copyright.h and the accompanying file COPYING
* See also accompanying file STS.COPYING
* ========================================================================
*/
/*
* ========================================================================
* Block-monobit test.
* Since we don't know what block size to use, try a bunch of block sizes.
* In particular, try all blocks sizes of 2^k words, where k={0..n}.
* Not sure what n should be. Especially considering the difficulty with
* getting a statistic out of the test.
* ========================================================================
*/
#include "../code_files/include/libdieharder.h"
#define BLOCK_MAX (16)
/* The evalMostExtreme function is in dab_dct.c */
extern double evalMostExtreme(double *pvalue, unsigned int num);
int dab_monobit2(Test **test, int irun)
{
unsigned int i, j;
unsigned int blens = rmax_bits;
unsigned int ntup = ntuple;
double *counts;
unsigned int *tempCount;
double pvalues[BLOCK_MAX];
/* First, find out the maximum block size to use.
* The maximum size will be 2^ntup words.
*/
if (ntup == 0) {
for (j=0;j<BLOCK_MAX;j++) {
unsigned int nmax = blens * (2<<j);
unsigned int nsamp = test[0]->tsamples / (2<<j);
if ( nsamp*gsl_ran_binomial_pdf(nmax/2,0.5,nmax) < 20 ) break;
}
ntup = j;
}
test[0]->ntuple = ntup;
counts = (double *) malloc(sizeof(*counts) * blens * (2<<ntup)); // 1 << (ntup+1)
memset(counts, 0, sizeof(*counts) * blens * (2<<ntup));
tempCount = (unsigned int *) malloc(sizeof(*tempCount) * ntup);
memset(tempCount, 0, sizeof(*tempCount) * ntup);
for(i=0;i<test[0]->tsamples;i++) {
unsigned int n = gsl_rng_get(rng);
unsigned int t = 1;
// Begin: count bits
n -= (n >> 1) & 0x55555555;
n = (n & 0x33333333) + ((n >> 2) & 0x33333333);
n = (n + (n >> 4)) & 0x0f0f0f0f;
if (0) {
n = (n * 0x01010101) >> 24;
} else {
n = n + (n >> 8);
n = (n + (n >> 16)) & 0x3f;
}
// End: count bits
for (j = 0; j < ntup; j++) {
tempCount[j] += n; // Update block count
if ((t & i) && !(t & (i-1))) { // If this is the start of a new block
counts[blens * ((2<<j)-1) + tempCount[j]]++; // Save the count
tempCount[j] = 0; // Reset the counter
}
t <<=1;
}
}
/* Calculate the p-value for each block size. */
for (j = 0; j < ntup; j++) {
double p = chisq_binomial(counts + (blens * ((2<<j)-1)), 0.5, blens * (2<<j),
test[0]->tsamples / (2<<j));
pvalues[j] = p;
}
/* Take only the most extreme p-value, and correct its value to
* account for the number of p-values considered.
*/
test[0]->pvalues[irun] = evalMostExtreme(pvalues, ntup);
nullfree(counts);
nullfree(tempCount);
return(0);
}
| [
"sovist9@ukr.net"
] | sovist9@ukr.net |
c47b288d5dece17657c56b4aeb517254a2fb0dcf | 5b24db41a9d2265e8c5cf1eca8001f235419ac81 | /Brush.hpp | 852968c6e97e963b711805e8f8a2187fe1c87788 | [] | no_license | mrkline/painter | 0909c4da9a381c77ef46e691ab654d32d6c1d9ac | 169a768c39eb502b43adb1b23f088bd676fffa05 | refs/heads/master | 2016-09-06T12:06:36.167182 | 2012-02-27T19:50:39 | 2012-10-29T13:58:14 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 354 | hpp | #pragma once
#include <cassert>
//! Provides a brush interface which returns an alpha mask value at a given
//! x-y coordinate
class Brush
{
public:
Brush(int radius)
: r(radius)
{ assert(r <= 15); }
virtual ~Brush() { }
int getRadius() const { return r; }
virtual unsigned char getValue(int x, int y) const = 0;
protected:
const int r;
};
| [
"slavik262@gmail.com"
] | slavik262@gmail.com |
a472bd09fd3203cb86b15217b3ee26a597a7b71d | 3f0d582175776fd7807751836020d980fab6d3ad | /include/qx/macros/assert.h | 52a22f90ab0cbfd991ea51356992f4e338ff61d6 | [
"MIT",
"LicenseRef-scancode-unknown-license-reference"
] | permissive | n0lavar/qxLib | a9fa54dac8e246c335465b713b2f3ae25103922f | 9d8e7c1156e15c58ab4ac8658f0e60d387b3c265 | refs/heads/master | 2023-08-08T01:09:56.123588 | 2023-07-26T18:34:06 | 2023-07-26T18:34:06 | 235,891,238 | 12 | 2 | null | 2021-07-23T20:58:02 | 2020-01-23T21:35:57 | C++ | WINDOWS-1252 | C++ | false | false | 18,327 | h | /**
@file assert.h
@brief Expect and assert macros
@author Khrapov
@date 29.10.2020
@copyright © Nick Khrapov, 2021. All right reserved.
**/
#pragma once
#include <qx/category.h>
#include <qx/logger/logger.h>
#include <exception>
#if QX_MSVC
#define _QX_DEBUG_BREAK __debugbreak()
#elif QX_CLANG
#define _QX_DEBUG_BREAK __builtin_debugtrap()
#elif QX_GNU
#include <signal.h>
#define _QX_DEBUG_BREAK raise(SIGTRAP)
#else
#define _QX_DEBUG_BREAK QX_EMPTY_MACRO
#endif
namespace qx::details
{
template<verbosity eVerbosity>
void resolve_assert_proceeding(
// macro args
const category& fileCategory,
string_view svFunction,
string_view svFile,
int nLine,
string_view svCondition)
{
QX_LOGGER_INSTANCE.log(eVerbosity, QX_TEXT("[{}] "), fileCategory, svFile, svFunction, nLine, svCondition);
QX_LOGGER_INSTANCE.flush();
}
template<verbosity eVerbosity>
void resolve_assert_proceeding(
// macro args
const category& fileCategory,
string_view svFunction,
string_view svFile,
int nLine,
string_view svCondition,
// ... args
const category& category)
{
string sMessage;
sMessage.append_format(QX_TEXT("[{}] "), svCondition);
QX_LOGGER_INSTANCE.log(eVerbosity, sMessage, category, svFile, svFunction, nLine);
QX_LOGGER_INSTANCE.flush();
}
template<verbosity eVerbosity, class... args_t>
requires log_acceptable_args<args_t...>
void resolve_assert_proceeding(
// macro args
const category& fileCategory,
string_view svFunction,
string_view svFile,
int nLine,
string_view svCondition,
// ... args
format_string<args_t...> sFormat,
const args_t&... args)
{
string sMessage;
sMessage.append_format(QX_TEXT("[{}] "), svCondition);
sMessage.append_format(sFormat, args...);
QX_LOGGER_INSTANCE.log(eVerbosity, sMessage, fileCategory, svFile, svFunction, nLine);
QX_LOGGER_INSTANCE.flush();
}
template<verbosity eVerbosity>
void resolve_assert_proceeding(
// macro args
const category& fileCategory,
string_view svFunction,
string_view svFile,
int nLine,
string_view svCondition,
// ... args
string_view svMessage)
{
string sMessage;
sMessage.append_format(QX_TEXT("[{}] {}"), svCondition, svMessage);
QX_LOGGER_INSTANCE.log(eVerbosity, sMessage, fileCategory, svFile, svFunction, nLine);
QX_LOGGER_INSTANCE.flush();
}
template<verbosity eVerbosity, class... args_t>
requires log_acceptable_args<args_t...>
void resolve_assert_proceeding(
// macro args
const category& fileCategory,
string_view svFunction,
string_view svFile,
int nLine,
string_view svCondition,
// ... args
const category& category,
format_string<args_t...> sFormat,
const args_t&... args)
{
string sMessage;
sMessage.append_format(QX_TEXT("[{}] "), svCondition);
sMessage.append_format(sFormat, args...);
QX_LOGGER_INSTANCE.log(eVerbosity, sMessage, category, svFile, svFunction, nLine);
QX_LOGGER_INSTANCE.flush();
}
template<verbosity eVerbosity>
void resolve_assert_proceeding(
// macro args
const category& fileCategory,
string_view svFunction,
string_view svFile,
int nLine,
string_view svCondition,
// ... args
const category& category,
string_view svMessage)
{
string sMessage;
sMessage.append_format(QX_TEXT("[{}] {}"), svCondition, svMessage);
QX_LOGGER_INSTANCE.log(eVerbosity, sMessage, category, svFile, svFunction, nLine);
QX_LOGGER_INSTANCE.flush();
}
} // namespace qx::details
// ----------------------------------- setup -----------------------------------
#ifndef QX_DEBUG_BREAK
#define QX_DEBUG_BREAK _QX_DEBUG_BREAK
#endif
#ifndef QX_EXPECT_BEFORE_DEBUG_BREAK
#define QX_EXPECT_BEFORE_DEBUG_BREAK(condition, ...) \
qx::details::resolve_assert_proceeding<qx::verbosity::error>( \
QX_FILE_CATEGORY(), \
qx::to_string(__FUNCTION__), \
QX_SHORT_FILE, \
__LINE__, \
QX_TEXT(#condition), \
##__VA_ARGS__)
#endif
#ifndef QX_EXPECT_DEBUG_BREAK
#if QX_DEBUG || QX_REL_WITH_DEBUG_INFO
#define QX_EXPECT_DEBUG_BREAK QX_DEBUG_BREAK
#else
#define QX_EXPECT_DEBUG_BREAK QX_EMPTY_MACRO
#endif
#endif
#ifndef QX_EXPECT_AFTER_DEBUG_BREAK
#define QX_EXPECT_AFTER_DEBUG_BREAK(condition, ...) QX_EMPTY_MACRO
#endif
#ifndef QX_ASSERT_BEFORE_DEBUG_BREAK
#define QX_ASSERT_BEFORE_DEBUG_BREAK(condition, ...) \
qx::details::resolve_assert_proceeding<qx::verbosity::critical>( \
QX_FILE_CATEGORY(), \
qx::to_string(__FUNCTION__), \
QX_SHORT_FILE, \
__LINE__, \
QX_TEXT(#condition), \
##__VA_ARGS__)
#endif
#ifndef QX_ASSERT_DEBUG_BREAK
#if QX_DEBUG || QX_REL_WITH_DEBUG_INFO
#define QX_ASSERT_DEBUG_BREAK QX_DEBUG_BREAK
#else
#define QX_ASSERT_DEBUG_BREAK QX_EMPTY_MACRO
#endif
#endif
#ifndef QX_ASSERT_AFTER_DEBUG_BREAK
#define QX_ASSERT_AFTER_DEBUG_BREAK(condition, ...) std::terminate()
#endif
// ------------------------------- common macros -------------------------------
#define _QX_ASSERT(before_debug_break, debug_break, after_debug_break, condition, ...) \
[&]() \
{ \
QX_PUSH_SUPPRESS_MSVC_WARNINGS(4702); \
if (!(condition)) [[unlikely]] \
{ \
before_debug_break(condition, ##__VA_ARGS__); \
debug_break; \
after_debug_break(condition, ##__VA_ARGS__); \
return false; \
} \
else \
{ \
return true; \
} \
QX_POP_SUPPRESS_WARNINGS(); \
}()
#define _QX_ASSERT_NO_ENTRY(before_debug_break, debug_break, after_debug_break, ...) \
_QX_ASSERT(before_debug_break, debug_break, after_debug_break, !QX_TEXT("No entry"), ##__VA_ARGS__)
#define _QX_ASSERT_CONTINUE(before_debug_break, debug_break, after_debug_break, condition, ...) \
if (!_QX_ASSERT(before_debug_break, debug_break, after_debug_break, condition, ##__VA_ARGS__)) [[unlikely]] \
continue; \
else \
QX_EMPTY_MACRO
#define _QX_ASSERT_BREAK(before_debug_break, debug_break, after_debug_break, condition, ...) \
if (!_QX_ASSERT(before_debug_break, debug_break, after_debug_break, condition, ##__VA_ARGS__)) [[unlikely]] \
break; \
else \
QX_EMPTY_MACRO
#define _QX_ASSERT_RETURN( \
before_debug_break, \
debug_break, \
after_debug_break, \
return_keyword, \
condition, \
return_value, \
...) \
if (!_QX_ASSERT(before_debug_break, debug_break, after_debug_break, condition, ##__VA_ARGS__)) [[unlikely]] \
return_keyword return_value; \
else \
QX_EMPTY_MACRO
// -------------------------------- user macros --------------------------------
/**
@brief Verifies that condition is true
@details ASSERT macros generate fatal failures and abort the program execution
@param condition - condition to check. if false, assert fails
@param ... - "category + format string + format arguments"
or "category + format string"
or "format string + format arguments"
or "format string"
or "category"
**/
#define QX_ASSERT(condition, ...) \
_QX_ASSERT( \
QX_ASSERT_BEFORE_DEBUG_BREAK, \
QX_ASSERT_DEBUG_BREAK, \
QX_ASSERT_AFTER_DEBUG_BREAK, \
condition, \
##__VA_ARGS__)
/**
@brief Fails unconditionally if this code should not be executed
@details ASSERT macros generate fatal failures and abort the program execution
@param ... - "category + format string + format arguments"
or "category + format string"
or "format string + format arguments"
or "format string"
or "category"
**/
#define QX_ASSERT_NO_ENTRY(...) \
_QX_ASSERT_NO_ENTRY(QX_ASSERT_BEFORE_DEBUG_BREAK, QX_ASSERT_DEBUG_BREAK, QX_ASSERT_AFTER_DEBUG_BREAK, ##__VA_ARGS__)
/**
@brief Verifies that condition is true
@details EXPECT macros generate nonfatal failures and allow to continue running
@param condition - condition to check. if false, assert fails
@param ... - "category + format string + format arguments"
or "category + format string"
or "format string + format arguments"
or "format string"
or "category"
**/
#define QX_EXPECT(condition, ...) \
_QX_ASSERT( \
QX_EXPECT_BEFORE_DEBUG_BREAK, \
QX_EXPECT_DEBUG_BREAK, \
QX_EXPECT_AFTER_DEBUG_BREAK, \
condition, \
##__VA_ARGS__)
/**
@brief Fails unconditionally if this code should not be executed
@details EXPECT macros generate nonfatal failures and allow to continue running
@param ... - "category + format string + format arguments"
or "category + format string"
or "format string + format arguments"
or "format string"
or "category"
**/
#define QX_EXPECT_NO_ENTRY(...) \
_QX_ASSERT_NO_ENTRY(QX_EXPECT_BEFORE_DEBUG_BREAK, QX_EXPECT_DEBUG_BREAK, QX_EXPECT_AFTER_DEBUG_BREAK, ##__VA_ARGS__)
/**
@brief Verifies that condition is true and continues loop if false
@details EXPECT macros generate nonfatal failures and allow to continue running
@param condition - condition to check. if false, assert fails
@param ... - "category + format string + format arguments"
or "category + format string"
or "format string + format arguments"
or "format string"
or "category"
**/
#define QX_EXPECT_CONTINUE(condition, ...) \
_QX_ASSERT_CONTINUE( \
QX_EXPECT_BEFORE_DEBUG_BREAK, \
QX_EXPECT_DEBUG_BREAK, \
QX_EXPECT_AFTER_DEBUG_BREAK, \
condition, \
##__VA_ARGS__)
/**
@brief Verifies that condition is true and break loop if false
@details EXPECT macros generate nonfatal failures and allow to continue running
@param condition - condition to check. if false, assert fails
@param ... - "category + format string + format arguments"
or "category + format string"
or "format string + format arguments"
or "format string"
or "category"
**/
#define QX_EXPECT_BREAK(condition, ...) \
_QX_ASSERT_BREAK( \
QX_EXPECT_BEFORE_DEBUG_BREAK, \
QX_EXPECT_DEBUG_BREAK, \
QX_EXPECT_AFTER_DEBUG_BREAK, \
condition, \
##__VA_ARGS__)
/**
@brief Verifies that condition is true and "return return_value;" if false
@details EXPECT macros generate nonfatal failures and allow to continue running
@param condition - condition to check. if false, assert fails
@param return_value - return value. use empty argument, if return type is void
@param ... - "category + format string + format arguments"
or "category + format string"
or "format string + format arguments"
or "format string"
or "category"
**/
#define QX_EXPECT_RETURN(condition, return_value, ...) \
_QX_ASSERT_RETURN( \
QX_EXPECT_BEFORE_DEBUG_BREAK, \
QX_EXPECT_DEBUG_BREAK, \
QX_EXPECT_AFTER_DEBUG_BREAK, \
return, \
condition, \
return_value, \
##__VA_ARGS__)
/**
@brief Verifies that condition is true and "return;" if false
@details EXPECT macros generate nonfatal failures and allow to continue running
@param condition - condition to check. if false, assert fails
@param ... - "category + format string + format arguments"
or "category + format string"
or "format string + format arguments"
or "format string"
or "category"
**/
#define QX_EXPECT_RETURN_VOID(condition, ...) \
_QX_ASSERT_RETURN( \
QX_EXPECT_BEFORE_DEBUG_BREAK, \
QX_EXPECT_DEBUG_BREAK, \
QX_EXPECT_AFTER_DEBUG_BREAK, \
return, \
condition, \
, \
##__VA_ARGS__)
/**
@brief Verifies that condition is true and "co_return return_value;" if false
@details EXPECT macros generate nonfatal failures and allow to continue running
@param condition - condition to check. if false, assert fails
@param return_value - return value. use empty argument, if return type is void
@param ... - "category + format string + format arguments"
or "category + format string"
or "format string + format arguments"
or "format string"
or "category"
**/
#define QX_EXPECT_CO_RETURN(condition, return_value, ...) \
_QX_ASSERT_RETURN( \
QX_EXPECT_BEFORE_DEBUG_BREAK, \
QX_EXPECT_DEBUG_BREAK, \
QX_EXPECT_AFTER_DEBUG_BREAK, \
co_return, \
condition, \
return_value, \
##__VA_ARGS__)
/**
@brief Verifies that condition is true and "co_return;" if false
@details EXPECT macros generate nonfatal failures and allow to continue running
@param condition - condition to check. if false, assert fails
@param ... - "category + format string + format arguments"
or "category + format string"
or "format string + format arguments"
or "format string"
or "category"
**/
#define QX_EXPECT_CO_RETURN_VOID(condition, ...) \
_QX_ASSERT_RETURN( \
QX_EXPECT_BEFORE_DEBUG_BREAK, \
QX_EXPECT_DEBUG_BREAK, \
QX_EXPECT_AFTER_DEBUG_BREAK, \
co_return, \
condition, \
, \
##__VA_ARGS__)
| [
"nick.khrapov@gmail.com"
] | nick.khrapov@gmail.com |
6a0621f2537dd0c7d17e4288cb4320bee6534719 | 53dee0a0db4c502876a2e5a74059410f4b1113d2 | /archived_data_testing_scripts/other_code/potential_energy_test.cpp | d392fbdd1fea2d78dcda8bbbcf451fa1525ad5de | [] | no_license | shelts/scripts | 3e3dccda74fb05805b4ddda2b8f223b8f362e3a1 | a239edbc896a3784c32f2b51c2d8527d4301ff39 | refs/heads/master | 2021-01-25T07:18:47.263755 | 2018-08-08T18:10:33 | 2018-08-08T18:10:33 | 38,136,619 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 12,262 | cpp | #include <iostream>
#include <fstream>
#include <cmath>
#include <tgmath.h>
#include <cstdlib>
#include <stdio.h>
#include <stdlib.h>
#include <typeinfo>
#include <vector>
#include <string>
#include <ctime>
using namespace std;
#define inv(x) ((double) 1.0 / (x))
#define seventh(x) ((x) * (x) * (x) * (x) * (x) * (x) * (x))
#define sixth(x) ((x) * (x) * (x) * (x) * (x) * (x))
#define fourth(x) ((x) * (x) * (x) * (x))
#define fifth(x) ((x) * (x) * (x) * (x) * (x))
#define cube(x) ((x) * (x) * (x))
#define sqr(x) ((x) * (x))
#define sqrdif(x, y) (sqr( (x) - (y) ))
#define seventhhalfs(x) ( sqrt(seventh(x) ) )
#define fivehalves(x) ( sqrt(fifth(x) ) )
#define threehalves(x) ( sqrt(cube(x) ) )
#define minusfivehalves(x) (inv(fivehalves(x)))
#define minusthreehalves(x) (inv(threehalves(x)) )
#define minushalf(x) ( inv(sqrt(x)) )
double randDouble(double low, double high)
{
double temp;
/* calculate the random number & return it */
temp = ((double) rand() / (static_cast<double>(RAND_MAX) + 1.0))* (high - low) + low;
return temp;
}
// // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // //
// theory functions
double density(double r, double * args)
{
double rscale_l = args[0];
double rscale_d = args[1];
double mass_l = args[2];
double mass_d = args[3];
double pi = 4.0 * atan(1.0);
double rscale_l_cube = cube(rscale_l);
double rscale_d_cube = cube(rscale_d);
// double density_result= (3.0/(4.0*pi))*(mass/rscalecube *pow(1+ sqr/sqrrcube, -2.5));
double density_light_comp = (mass_l/rscale_l_cube) * minusfivehalves( (1.0 + sqr(r)/sqr(rscale_l) ) );
double density_dark_comp = (mass_d/rscale_d_cube) * minusfivehalves( (1.0 + sqr(r)/sqr(rscale_d) ) );
double coeff = 3.0 / (4.0 * pi);
double density_result = coeff * ( density_light_comp + density_dark_comp);
return density_result;
}
double mass_enc(double r, double * args)
{
double rscale_l = args[0];
double rscale_d = args[1];
double mass_l = args[2];
double mass_d = args[3];
double rcube = cube(r);
double mass_enclosed_l = mass_l * rcube * pow( (sqr(r) + sqr(rscale_l) ), -1.5);
double mass_enclosed_d = mass_d * rcube * pow( (sqr(r) + sqr(rscale_d) ), -1.5);
double mass_enclosed = mass_enclosed_l + mass_enclosed_d;
return mass_enclosed;
}
double potential( double r, double * args)
{
double rscale_l = args[0];
double rscale_d = args[1];
double mass_l = args[2];
double mass_d = args[3];
double pot_light_comp = mass_l/sqrt( sqr(r) + sqr(rscale_l) );
double pot_dark_comp = mass_d/sqrt( sqr(r) + sqr(rscale_d) );
double potential_result = -1.0 * (pot_light_comp + pot_dark_comp);
return (potential_result);
}
double potential_total_int(double r, double * comp_args, double * args)
{
/*total potential energy, calculated by integrating this function*/
double pi = 4.0 * atan(1.0);
double pot = potential(r, args);
double den = density(r, comp_args);
double func = sqr(r) * pot * den;
// printf("func = %f pot = %f den = %f \n", func, pot, den);
return func;
}
double potential_total_calc(double r, double * args)
{
/*from a analytical calc. Does not work for combined compoenents*/
double rscale_l = args[0];
double rscale_d = args[1];
double mass_l = args[2];
double mass_d = args[3];
double pi= 4.0 * atan(1.0);
double func_light_comp = 3.0 * sqr(mass_l) * inv(2.0 * sixth(rscale_l)) * fourth(r) * inv( sqr( 1.0 + sqr(r)/sqr(rscale_l)) );
double func_dark_comp = 3.0 * sqr(mass_d) * inv(2.0 * sixth(rscale_d)) * fourth(r) * inv( sqr( 1.0 + sqr(r)/sqr(rscale_d)) );
double func = (func_light_comp + func_dark_comp);
// printf("func = %f pot = %f den = %f \n", func, pot, den);
return func;
}
// // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // //
// service functions
static double gauss_quad(double (*rootFunc)(double, double *, double *), double * comp_args, double * args, double lower, double upper )
{
double Ng,hg,lowerg, upperg;
double intv;
double coef1,coef2;//parameters for gaussian quad
double c1, c2, c3;
double x1, x2, x3;
double x1n, x2n, x3n;
//this should be from infinity. But the dis func should be negligble here.
double a = lower;
double b = upper;
intv = 0;//initial value of integral
Ng = 1000.0;//integral resolution
hg = (b-a)/(Ng);
lowerg = lower;
upperg = lowerg + hg;
coef2 = (lowerg+upperg)/2.0;//initializes the first coeff to change the function limits
coef1 = (upperg-lowerg)/2.0;//initializes the second coeff to change the function limits
c1 = 5.0/9.0;
c2 = 8.0/9.0;
c3 = 5.0/9.0;
x1 = -sqrt(3.0/5.0);
x2 = 0.0;
x3 = sqrt(3.0/5.0);
x1n = (coef1 * x1 + coef2);
x2n = (coef1 * x2 + coef2);
x3n = (coef1 * x3 + coef2);
int counter=0;
while (1)
{
//gauss quad
intv = intv + c1 * (*rootFunc)(x1n, comp_args, args) * coef1 +
c2 * (*rootFunc)(x2n, comp_args, args) * coef1 +
c3 * (*rootFunc)(x3n, comp_args, args) * coef1;
lowerg = upperg;
upperg = upperg + hg;
coef2 = (lowerg + upperg)/2.0;//initializes the first coeff to change the function limits
coef1 = (upperg - lowerg)/2.0;
x1n = ((coef1) * x1 + coef2);
x2n = ((coef1) * x2 + coef2);
x3n = ((coef1) * x3 + coef2);
if(upper > lower)
{
if(lowerg >= upper)//loop termination clause
{
break;
}
}
else if(lower > upper)
{
if(lowerg <= upper)//loop termination clause
{
break;
}
}
counter++;
}
return intv;
}
// // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // //
// theory checking functions
void potential_theory(double bin_width, double * args)
{
double rscale_l = args[0];
double rscale_d = args[1];
double mass_l = args[2];
double mass_d = args[3];
double masspl = args[4];
double masspd = args[5];
double light[4] = {rscale_l, rscale_d, mass_l, 0.0};
double dark[4] = {rscale_l, rscale_d, 0.0, mass_d};
double pot_all, pot_l, pot_d;
double pi = 4.0 * atan(1.0);
double w = 0.0;
double pot_pp_l;
double pot_pp_d;
//done via integral:
FILE * pot;
pot= fopen("./theory/theory_pot_int.dat", "w");
while(1)
{
pot_pp_l = ( potential(w, light) );
pot_pp_d = ( potential(w, dark) );
pot_l = 4.0 * pi * bin_width * inv(pot_pp_l * masspl ) * potential_total_int(w, light, args); //gauss_quad(potential_total_int, light, 0.0, w);
pot_d = 4.0 * pi * bin_width * inv(pot_pp_d * masspd ) * potential_total_int(w, dark, args); //gauss_quad(potential_total_int, dark, 0.0, w);
pot_all = 4.0 * pi * bin_width * potential_total_int(w, args, args); //gauss_quad(potential_total_int, args, 0.0, w);
// printf( "%f\t%f\t%f\t%f\n", pot_pp_l, pot_pp_d , pot_l, pot_all);
w += 0.01;
fprintf(pot, "%f\t%f\t%f\t%f\n", pot_pp_l, pot_pp_d , pot_l, pot_d);
if( fabs(w) > 5 * (rscale_l + rscale_d)){break;}
}
fclose(pot);
//done via analytical calc
FILE * pot2;
pot2= fopen("./theory/theory_pot_calc.dat", "w");
w = 0.0;
while(1)
{
pot_pp_l = potential(w, light);
pot_pp_d = potential(w, dark);
pot_l = potential_total_calc(w, light) ;
pot_d = potential_total_calc(w, dark) ;
pot_all = pot_l + pot_d;//not corrects
w += 0.01;
fprintf(pot2, "%f \t %f \t %f\t%f\n", pot_pp_l, pot_pp_d, pot_l, pot_d);
if( w > 5 * (rscale_l + rscale_d)){break;}
}
fclose(pot2);
/* CALCULATION OF TOTAL POTENTIAL ENERGY */
//single density against both potentials
double r_inf = 50.0 * (rscale_l + rscale_d);
pot_l = 4.0 * pi * gauss_quad(potential_total_int, light, args, 0.0, r_inf);
pot_d = 4.0 * pi * gauss_quad(potential_total_int, dark, args, 0.0, r_inf);
double sum = pot_l + pot_d;
// printf("\npot_l = %f \t pot_d = %f \t sum = %f\n", pot_l, pot_d, sum);
//single density against single potentials
pot_l = 4.0 * pi * gauss_quad(potential_total_int, light, light, 0.0, r_inf);
pot_d = 4.0 * pi * gauss_quad(potential_total_int, dark, dark, 0.0, r_inf);
sum = pot_l + pot_d;
// printf("\npot_l = %f \t pot_d = %f \t sum = %f\n", pot_l, pot_d, sum);
}
// // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // //
// actual data checking function
void potential_distribution(double bin_width, double number_of_bins, string extension, double * args, double * rl, int Nl, double * rd, int Nd)
{
double rscale_l = args[0];
double rscale_d = args[1];
double mass_l = args[2];
double mass_d = args[3];
double masspl = args[4];
double masspd = args[5];
string s;
int type = 2;
double light[4] = {rscale_l, rscale_d, mass_l, 0.0};
double dark[4] = {rscale_l, rscale_d, 0.0, mass_d};
double pot_d[Nd];
double pot_l[Nl];
double r;
double pot[Nd + Nl];
ofstream pod;
pod.open("./actual/dark_potential_" + extension + ".dat");
ofstream pol;
pol.open("./actual/light_potential_" + extension + ".dat");
int j = 0;
for(int i = 0; i < Nd; i++)
{
r = rd[i];
pot_d[i] = potential(r, dark);
pod<<r <<"\t"<<pot_d[i]<<endl;
pot[j] = pot_d[i];
j++;
}
for(int i = 0; i < Nl; i++)
{
r = rl[i];
pot_l[i] = potential(r, light);
pol<<r <<"\t"<<pot_l[i]<<endl;
pot[j] = pot_l[i];
j++;
}
pol.close();
pod.close();
s = string("binned_data/pot_dark_"+extension+".dat");
binner(number_of_bins, bin_width, pot_d, Nd, s, extension, type);
s = string("binned_data/pot_light_"+extension+".dat");
binner(number_of_bins, bin_width, pot_l, Nl, s, extension, type);
// s = string("binned_data/pot_"+extension+".dat");
// binner(number_of_bins, bin_width, pot, Nd + Nl, type, extension, type);
}
// // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // //
// main function calls
int main (int argc, char * const argv[])
{
srand(time(NULL));
string simtime = argv[1];
double rscale_l = atof(argv[2]);
double rscale_d = atof(argv[3]);
double mass_l = atof(argv[4]);
double mass_d = atof(argv[5]);
double mass_per_particle_light = atof(argv[6]);
double mass_per_particle_dark = atof(argv[7]);
string extension = simtime + "gy";
// printf("massl = %f massd = %f rscale_l = %f rscale_d = %f\n", mass_l, mass_d, rscale_l, rscale_d);
double args[6] = {rscale_l, rscale_d, mass_l, mass_d, mass_per_particle_light, mass_per_particle_dark};
// printf("rad_light= %f \t rad_dark=%f \n mass_light=%f \t mass_dark=%f\n", rscale_l, rscale_d, mass_l, mass_d);
/*paramters for binning routine*/
int number_of_bins = 1000;
double bin_width = .10;
/*these are markers for the type of data being sent into functions*/
/*get center of mass*/
mass = mass_l + mass_d;
/*getting the radii and vel vectors*/
/*no longer neccessary. Used to calculate the total potential energy, actual and theory*/
printf(".");
potential_distribution(bin_width, number_of_bins, extension, args, rl, Nl, rd, Nd);
printf(".");
potential_theory(bin_width, args);
printf("done.\n");
}
| [
"shelts@rpi.edu"
] | shelts@rpi.edu |
897bf84ce2941eb7c1ac0121f29fc4af8f7785de | 606dc44ed1d1511da6ddf0a1cdbd802c6e368b91 | /minions/Oasis_DHT22_60xLEDs/Oasis_DHT22_60xLEDs.ino | f00c293eba11fc1216e53df543bc12df21fe7807 | [
"CC0-1.0"
] | permissive | rugbprop/oasis-grow | 813f95c4279fd05f89f03d8f88da0911d5792fac | 9e36d94e76779c72f90a9f3f2eab7fe95383c946 | refs/heads/master | 2023-08-30T15:21:35.136191 | 2021-11-16T02:31:59 | 2021-11-16T02:31:59 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,604 | ino | //Include modules
#include <Wire.h>
#include <DHT.h>
#include <FastLED.h>
// intiialize temp & hum sensor
#define DHTTYPE DHT22 // DHT 22 (AM2302)
#define DHTPIN 5
DHT dht(DHTPIN, DHTTYPE);
//sensor pin for water level
//int water_level_pin = 2;
//set up LED controller
#define LEDPIN 7
#define NUMOFLEDS 60
CRGB leds[NUMOFLEDS];
String led_mode = "off";
void setup() {
FastLED.addLeds<WS2812B, LEDPIN, GRB>(leds, NUMOFLEDS);
Serial.begin(9600);
dht.begin();
while (!Serial) {
delay(10);
}
//pinMode(water_level_pin, INPUT_PULLUP);
//off (none, looping)
if (led_mode == "off"){
for (int i = 0; i <= 59; i++) {
leds[i] = CRGB (0, 0, 0);
FastLED.show();
delay(40);
}
}
}
//int waterSig4 = 0;
//int waterSig3 = 0;
//int waterSig2 = 0;
//int waterSig1 = 0;
//int waterSig0 = 0;
void loop() {
//Serial Data Out
float temperature, humidity;
int water_low = 0;
humidity = dht.readHumidity();
temperature = dht.readTemperature();
//if (digitalRead(water_level_pin) == HIGH)
//{
// waterSig0 = waterSig1;
// waterSig1 = waterSig2;
// waterSig2 = waterSig3;
// waterSig3 = waterSig4;
// waterSig4 = 1;
//}
//else
//{
// waterSig0 = waterSig1;
// waterSig1 = waterSig2;
// waterSig2 = waterSig3;
// waterSig3 = waterSig4;
// waterSig4 = 0;
// }
//if (waterSig4 == 1 || waterSig3 == 1 || waterSig2 == 1 || waterSig1 == 1 || waterSig0 == 1)
// {
// water_low = 1;
// }
// else
// {
// water_low = 0;
//}
Serial.print(humidity);
Serial.print(" ");
Serial.print(temperature*(1.800)+32); //need to manually adjust the sensor smh
Serial.print(" ");
Serial.print(water_low);
Serial.println();
//Mode Management
if (Serial.available() > 0) {
String led_data = Serial.readStringUntil('\n');
led_mode = led_data;
}
//Connected, Running (green, looping)
if (led_mode =="connected_running"){
for (int i = 0; i <= 59; i++) {
leds[i] = CRGB (0, 10, 0);
FastLED.show();
delay(40);
}
for (int i = 0; i <= 59; i++) {
leds[i] = CRGB (0, 5, 0);
FastLED.show();
delay(40);
}
}
//Connected, Idle (green, static)
if (led_mode =="connected_idle"){
for (int i = 0; i <= 59; i++) {
leds[i] = CRGB (0, 5, 0);
FastLED.show();
delay(40);
}
}
//Island, Running (white, looping)
if (led_mode =="offline_running"){
for (int i = 0; i <= 59; i++) {
leds[i] = CRGB (10, 10, 10);
FastLED.show();
delay(40);
}
for (int i = 0; i <= 59; i++) {
leds[i] = CRGB (5, 5, 5);
FastLED.show();
delay(40);
}
}
//Island, Idle (white, static)
if (led_mode =="offline_idle"){
for (int i = 0; i <= 59; i++) {
leds[i] = CRGB (5, 5, 5);
FastLED.show();
delay(40);
}
}
//Master sends error message (red, static)
if (led_mode =="error"){
for (int i = 0; i <= 59; i++) {
leds[i] = CRGB (5, 0, 0);
FastLED.show();
delay(40);
}
}
//AP-mode, Server accepting connections (blue, looping)
if (led_mode =="accepting_wifi_connection"){
for (int i = 0; i <= 59; i++) {
leds[i] = CRGB (0, 0, 10);
FastLED.show();
delay(40);
}
for (int i = 0; i <= 59; i++) {
leds[i] = CRGB (0, 0, 5);
FastLED.show();
delay(40);
}
}
//off (none, looping)
if (led_mode == "off"){
for (int i = 0; i <= 59; i++) {
leds[i] = CRGB (0, 0, 0);
FastLED.show();
delay(40);
}
}
//Serial.println(led_mode);
delay(1);
}
| [
"leemichael289@gmail.com"
] | leemichael289@gmail.com |
3a9aa7fe2f07a7b74ba69794b070bc5be8df4b21 | 5fe3c551dd680d9578303aff7afdf4e29d049caa | /src/test/main_tests.cpp | c88d5c2ad0897068b7769d713ad67109b5752486 | [
"MIT"
] | permissive | globalsmartasset/globalsmartasset_old | cb54012762bd338dbb6563d8b2f48341cd836869 | 88b8ac2c6396299a80d08c3c412035585b52b301 | refs/heads/master | 2020-07-15T00:39:24.818402 | 2019-09-05T11:35:06 | 2019-09-05T11:35:06 | 205,438,049 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,610 | cpp | // Copyright (c) 2014 The Bitcoin Core developers
// Copyright (c) 2014-2015 The Dash developers
// Copyright (c) 2015-2017 The PIVX developers
// Distributed under the MIT/X11 software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#include "primitives/transaction.h"
#include "main.h"
#include <boost/test/unit_test.hpp>
BOOST_AUTO_TEST_SUITE(main_tests)
CAmount nMoneySupplyPoWEnd = 43199500 * COIN;
BOOST_AUTO_TEST_CASE(subsidy_limit_test)
{
CAmount nSum = 0;
for (int nHeight = 0; nHeight < 1; nHeight += 1) {
/* premine in block 1 (60,001 globalsmartasset) */
CAmount nSubsidy = GetBlockValue(nHeight);
BOOST_CHECK(nSubsidy <= 60001 * COIN);
nSum += nSubsidy;
}
for (int nHeight = 1; nHeight < 86400; nHeight += 1) {
/* PoW Phase One */
CAmount nSubsidy = GetBlockValue(nHeight);
BOOST_CHECK(nSubsidy <= 250 * COIN);
nSum += nSubsidy;
}
for (int nHeight = 86400; nHeight < 151200; nHeight += 1) {
/* PoW Phase Two */
CAmount nSubsidy = GetBlockValue(nHeight);
BOOST_CHECK(nSubsidy <= 225 * COIN);
nSum += nSubsidy;
}
for (int nHeight = 151200; nHeight < 259200; nHeight += 1) {
/* PoW Phase Two */
CAmount nSubsidy = GetBlockValue(nHeight);
BOOST_CHECK(nSubsidy <= 45 * COIN);
BOOST_CHECK(MoneyRange(nSubsidy));
nSum += nSubsidy;
BOOST_CHECK(nSum > 0 && nSum <= nMoneySupplyPoWEnd);
}
BOOST_CHECK(nSum == 4109975100000000ULL);
}
BOOST_AUTO_TEST_SUITE_END()
| [
"globalsmartasset@gmail.com"
] | globalsmartasset@gmail.com |
83dd467c3dfb7036af12ab30603138396208a102 | 92c43f9c66816e3b5424b93aa27f15b081905549 | /Part7/LogicalNodes/DomainLNs/LNGroupC/GroupC.cpp | 2c5d7a4eacaa1647a5ca752eb4e79667e387eccc | [] | no_license | adirkuhn/lib-iec61850 | fd30b032b35d3184c3f01be4f0a11a3560c7954f | 7a35d901a299c94e49fd4dcb468a9d0e993b0709 | refs/heads/master | 2020-05-21T12:11:30.042930 | 2014-10-27T17:51:18 | 2014-10-27T17:51:18 | 32,832,932 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 288 | cpp | ///////////////////////////////////////////////////////////
// GroupC.h
// Implementation of the Class GroupC
// Created on: 01-Oct-2014 2:52:20 PM
// Original author: adirkuhn
///////////////////////////////////////////////////////////
#include "GroupC.h"
GroupC::GroupC()
{
}
| [
"adirkuhn@gmail.com"
] | adirkuhn@gmail.com |
1266e11f0f57ff2b7931c6617a9ba2d39151b47a | dca4718b3594a263f714c1d43eabbf39a7642d53 | /Software/Accel_VelocityAccPrint/Accel_VelocityAccPrint.ino | f99c35ca2953a55171ab365709211a1ef6edb23d | [] | no_license | yekrutdloc/Hovercraft-Project | 731dc0388173f8828cbd4b9d0919c572a9c608c2 | 607d96cdfd811057ae92c67010e5b876eb003425 | refs/heads/master | 2021-06-27T03:53:07.877321 | 2017-09-19T07:56:29 | 2017-09-19T07:56:29 | 104,043,210 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 40,831 | ino |
//
// Accel_VelocityAccPrint.ino
//
// Purpose: This Sketch is currently in development.
// Most of the code is taken from Arduino.cc
// The Sketch calculates velocity from accelerometer data
// This Sketch gets accelerometer data from the MPU-6050
// which then runs the values through a low-pass filter written by "Krodal"
// A calibration written by Prince Balabis runs at the start of the program -
// in order to calculate zero acceleration with gravity-affection removed.
// Also the calibration enables "real accleration"-calculation,
// which in other words mean the real acceleration is calculated
// independent from gravity.
//
// @author Prince Balabis
// MPU-6050 Accelerometer + Gyro
// -----------------------------
//
// By arduino.cc user "Krodal".
// June 2012
// Open Source / Public Domain
//
// Using Arduino 1.0.1
// It will not work with an older version,
// since Wire.endTransmission() uses a parameter
// to hold or release the I2C bus.
//
// Documentation:
// - The InvenSense documents:
// - "MPU-6000 and MPU-6050 Product Specification",
// PS-MPU-6000A.pdf
// - "MPU-6000 and MPU-6050 Register Map and Descriptions",
// RM-MPU-6000A.pdf or RS-MPU-6000A.pdf
// - "MPU-6000/MPU-6050 9-Axis Evaluation Board User Guide"
// AN-MPU-6000EVB.pdf
//
// The accuracy is 16-bits.
//
// Temperature sensor from -40 to +85 degrees Celsius
// 340 per degrees, -512 at 35 degrees.
//
// At power-up, all registers are zero, except these two:
// Register 0x6B (PWR_MGMT_2) = 0x40 (I read zero).
// Register 0x75 (WHO_AM_I) = 0x68.
//
#include <Wire.h>
//Custom Calibration variables
int const customCalibrationTime = 200;
int calibrationTimes = 0;
float maxAccValue = -5000;
float minAccValue = 5000;
float zeroAccCalValue = 0;
float v;
// The name of the sensor is "MPU-6050".
// For program code, I omit the '-',
// therefor I use the name "MPU6050....".
// Register names according to the datasheet.
// According to the InvenSense document
// "MPU-6000 and MPU-6050 Register Map
// and Descriptions Revision 3.2", there are no registers
// at 0x02 ... 0x18, but according other information
// the registers in that unknown area are for gain
// and offsets.
//a
#define MPU6050_AUX_VDDIO 0x01 // R/W
#define MPU6050_SMPLRT_DIV 0x19 // R/W
#define MPU6050_CONFIG 0x1A // R/W
#define MPU6050_GYRO_CONFIG 0x1B // R/W
#define MPU6050_ACCEL_CONFIG 0x1C // R/W
#define MPU6050_FF_THR 0x1D // R/W
#define MPU6050_FF_DUR 0x1E // R/W
#define MPU6050_MOT_THR 0x1F // R/W
#define MPU6050_MOT_DUR 0x20 // R/W
#define MPU6050_ZRMOT_THR 0x21 // R/W
#define MPU6050_ZRMOT_DUR 0x22 // R/W
#define MPU6050_FIFO_EN 0x23 // R/W
#define MPU6050_I2C_MST_CTRL 0x24 // R/W
#define MPU6050_I2C_SLV0_ADDR 0x25 // R/W
#define MPU6050_I2C_SLV0_REG 0x26 // R/W
#define MPU6050_I2C_SLV0_CTRL 0x27 // R/W
#define MPU6050_I2C_SLV1_ADDR 0x28 // R/W
#define MPU6050_I2C_SLV1_REG 0x29 // R/W
#define MPU6050_I2C_SLV1_CTRL 0x2A // R/W
#define MPU6050_I2C_SLV2_ADDR 0x2B // R/W
#define MPU6050_I2C_SLV2_REG 0x2C // R/W
#define MPU6050_I2C_SLV2_CTRL 0x2D // R/W
#define MPU6050_I2C_SLV3_ADDR 0x2E // R/W
#define MPU6050_I2C_SLV3_REG 0x2F // R/W
#define MPU6050_I2C_SLV3_CTRL 0x30 // R/W
#define MPU6050_I2C_SLV4_ADDR 0x31 // R/W
#define MPU6050_I2C_SLV4_REG 0x32 // R/W
#define MPU6050_I2C_SLV4_DO 0x33 // R/W
#define MPU6050_I2C_SLV4_CTRL 0x34 // R/W
#define MPU6050_I2C_SLV4_DI 0x35 // R
#define MPU6050_I2C_MST_STATUS 0x36 // R
#define MPU6050_INT_PIN_CFG 0x37 // R/W
#define MPU6050_INT_ENABLE 0x38 // R/W
#define MPU6050_INT_STATUS 0x3A // R
#define MPU6050_ACCEL_XOUT_H 0x3B // R
#define MPU6050_ACCEL_XOUT_L 0x3C // R
#define MPU6050_ACCEL_YOUT_H 0x3D // R
#define MPU6050_ACCEL_YOUT_L 0x3E // R
#define MPU6050_ACCEL_ZOUT_H 0x3F // R
#define MPU6050_ACCEL_ZOUT_L 0x40 // R
#define MPU6050_TEMP_OUT_H 0x41 // R
#define MPU6050_TEMP_OUT_L 0x42 // R
#define MPU6050_GYRO_XOUT_H 0x43 // R
#define MPU6050_GYRO_XOUT_L 0x44 // R
#define MPU6050_GYRO_YOUT_H 0x45 // R
#define MPU6050_GYRO_YOUT_L 0x46 // R
#define MPU6050_GYRO_ZOUT_H 0x47 // R
#define MPU6050_GYRO_ZOUT_L 0x48 // R
#define MPU6050_EXT_SENS_DATA_00 0x49 // R
#define MPU6050_EXT_SENS_DATA_01 0x4A // R
#define MPU6050_EXT_SENS_DATA_02 0x4B // R
#define MPU6050_EXT_SENS_DATA_03 0x4C // R
#define MPU6050_EXT_SENS_DATA_04 0x4D // R
#define MPU6050_EXT_SENS_DATA_05 0x4E // R
#define MPU6050_EXT_SENS_DATA_06 0x4F // R
#define MPU6050_EXT_SENS_DATA_07 0x50 // R
#define MPU6050_EXT_SENS_DATA_08 0x51 // R
#define MPU6050_EXT_SENS_DATA_09 0x52 // R
#define MPU6050_EXT_SENS_DATA_10 0x53 // R
#define MPU6050_EXT_SENS_DATA_11 0x54 // R
#define MPU6050_EXT_SENS_DATA_12 0x55 // R
#define MPU6050_EXT_SENS_DATA_13 0x56 // R
#define MPU6050_EXT_SENS_DATA_14 0x57 // R
#define MPU6050_EXT_SENS_DATA_15 0x58 // R
#define MPU6050_EXT_SENS_DATA_16 0x59 // R
#define MPU6050_EXT_SENS_DATA_17 0x5A // R
#define MPU6050_EXT_SENS_DATA_18 0x5B // R
#define MPU6050_EXT_SENS_DATA_19 0x5C // R
#define MPU6050_EXT_SENS_DATA_20 0x5D // R
#define MPU6050_EXT_SENS_DATA_21 0x5E // R
#define MPU6050_EXT_SENS_DATA_22 0x5F // R
#define MPU6050_EXT_SENS_DATA_23 0x60 // R
#define MPU6050_MOT_DETECT_STATUS 0x61 // R
#define MPU6050_I2C_SLV0_DO 0x63 // R/W
#define MPU6050_I2C_SLV1_DO 0x64 // R/W
#define MPU6050_I2C_SLV2_DO 0x65 // R/W
#define MPU6050_I2C_SLV3_DO 0x66 // R/W
#define MPU6050_I2C_MST_DELAY_CTRL 0x67 // R/W
#define MPU6050_SIGNAL_PATH_RESET 0x68 // R/W
#define MPU6050_MOT_DETECT_CTRL 0x69 // R/W
#define MPU6050_USER_CTRL 0x6A // R/W
#define MPU6050_PWR_MGMT_1 0x6B // R/W
#define MPU6050_PWR_MGMT_2 0x6C // R/W
#define MPU6050_FIFO_COUNTH 0x72 // R/W
#define MPU6050_FIFO_COUNTL 0x73 // R/W
#define MPU6050_FIFO_R_W 0x74 // R/W
#define MPU6050_WHO_AM_I 0x75 // R
// Defines for the bits, to be able to change
// between bit number and binary definition.
// By using the bit number, programming the sensor
// is like programming the AVR microcontroller.
// But instead of using "(1<<X)", or "_BV(X)",
// the Arduino "bit(X)" is used.
#define MPU6050_D0 0
#define MPU6050_D1 1
#define MPU6050_D2 2
#define MPU6050_D3 3
#define MPU6050_D4 4
#define MPU6050_D5 5
#define MPU6050_D6 6
#define MPU6050_D7 7
// AUX_VDDIO Register
#define MPU6050_AUX_VDDIO MPU6050_D7 // I2C high: 1=VDD, 0=VLOGIC
// CONFIG Register
// DLPF is Digital Low Pass Filter for both gyro and accelerometers.
// These are the names for the bits.
// Use these only with the bit() macro.
#define MPU6050_DLPF_CFG0 MPU6050_D0
#define MPU6050_DLPF_CFG1 MPU6050_D1
#define MPU6050_DLPF_CFG2 MPU6050_D2
#define MPU6050_EXT_SYNC_SET0 MPU6050_D3
#define MPU6050_EXT_SYNC_SET1 MPU6050_D4
#define MPU6050_EXT_SYNC_SET2 MPU6050_D5
// Combined definitions for the EXT_SYNC_SET values
#define MPU6050_EXT_SYNC_SET_0 (0)
#define MPU6050_EXT_SYNC_SET_1 (bit(MPU6050_EXT_SYNC_SET0))
#define MPU6050_EXT_SYNC_SET_2 (bit(MPU6050_EXT_SYNC_SET1))
#define MPU6050_EXT_SYNC_SET_3 (bit(MPU6050_EXT_SYNC_SET1)|bit(MPU6050_EXT_SYNC_SET0))
#define MPU6050_EXT_SYNC_SET_4 (bit(MPU6050_EXT_SYNC_SET2))
#define MPU6050_EXT_SYNC_SET_5 (bit(MPU6050_EXT_SYNC_SET2)|bit(MPU6050_EXT_SYNC_SET0))
#define MPU6050_EXT_SYNC_SET_6 (bit(MPU6050_EXT_SYNC_SET2)|bit(MPU6050_EXT_SYNC_SET1))
#define MPU6050_EXT_SYNC_SET_7 (bit(MPU6050_EXT_SYNC_SET2)|bit(MPU6050_EXT_SYNC_SET1)|bit(MPU6050_EXT_SYNC_SET0))
// Alternative names for the combined definitions.
#define MPU6050_EXT_SYNC_DISABLED MPU6050_EXT_SYNC_SET_0
#define MPU6050_EXT_SYNC_TEMP_OUT_L MPU6050_EXT_SYNC_SET_1
#define MPU6050_EXT_SYNC_GYRO_XOUT_L MPU6050_EXT_SYNC_SET_2
#define MPU6050_EXT_SYNC_GYRO_YOUT_L MPU6050_EXT_SYNC_SET_3
#define MPU6050_EXT_SYNC_GYRO_ZOUT_L MPU6050_EXT_SYNC_SET_4
#define MPU6050_EXT_SYNC_ACCEL_XOUT_L MPU6050_EXT_SYNC_SET_5
#define MPU6050_EXT_SYNC_ACCEL_YOUT_L MPU6050_EXT_SYNC_SET_6
#define MPU6050_EXT_SYNC_ACCEL_ZOUT_L MPU6050_EXT_SYNC_SET_7
// Combined definitions for the DLPF_CFG values
#define MPU6050_DLPF_CFG_0 (0)
#define MPU6050_DLPF_CFG_1 (bit(MPU6050_DLPF_CFG0))
#define MPU6050_DLPF_CFG_2 (bit(MPU6050_DLPF_CFG1))
#define MPU6050_DLPF_CFG_3 (bit(MPU6050_DLPF_CFG1)|bit(MPU6050_DLPF_CFG0))
#define MPU6050_DLPF_CFG_4 (bit(MPU6050_DLPF_CFG2))
#define MPU6050_DLPF_CFG_5 (bit(MPU6050_DLPF_CFG2)|bit(MPU6050_DLPF_CFG0))
#define MPU6050_DLPF_CFG_6 (bit(MPU6050_DLPF_CFG2)|bit(MPU6050_DLPF_CFG1))
#define MPU6050_DLPF_CFG_7 (bit(MPU6050_DLPF_CFG2)|bit(MPU6050_DLPF_CFG1)|bit(MPU6050_DLPF_CFG0))
// Alternative names for the combined definitions
// This name uses the bandwidth (Hz) for the accelometer,
// for the gyro the bandwidth is almost the same.
#define MPU6050_DLPF_260HZ MPU6050_DLPF_CFG_0
#define MPU6050_DLPF_184HZ MPU6050_DLPF_CFG_1
#define MPU6050_DLPF_94HZ MPU6050_DLPF_CFG_2
#define MPU6050_DLPF_44HZ MPU6050_DLPF_CFG_3
#define MPU6050_DLPF_21HZ MPU6050_DLPF_CFG_4
#define MPU6050_DLPF_10HZ MPU6050_DLPF_CFG_5
#define MPU6050_DLPF_5HZ MPU6050_DLPF_CFG_6
#define MPU6050_DLPF_RESERVED MPU6050_DLPF_CFG_7
// GYRO_CONFIG Register
// The XG_ST, YG_ST, ZG_ST are bits for selftest.
// The FS_SEL sets the range for the gyro.
// These are the names for the bits.
// Use these only with the bit() macro.
#define MPU6050_FS_SEL0 MPU6050_D3
#define MPU6050_FS_SEL1 MPU6050_D4
#define MPU6050_ZG_ST MPU6050_D5
#define MPU6050_YG_ST MPU6050_D6
#define MPU6050_XG_ST MPU6050_D7
// Combined definitions for the FS_SEL values
#define MPU6050_FS_SEL_0 (0)
#define MPU6050_FS_SEL_1 (bit(MPU6050_FS_SEL0))
#define MPU6050_FS_SEL_2 (bit(MPU6050_FS_SEL1))
#define MPU6050_FS_SEL_3 (bit(MPU6050_FS_SEL1)|bit(MPU6050_FS_SEL0))
// Alternative names for the combined definitions
// The name uses the range in degrees per second.
#define MPU6050_FS_SEL_250 MPU6050_FS_SEL_0
#define MPU6050_FS_SEL_500 MPU6050_FS_SEL_1
#define MPU6050_FS_SEL_1000 MPU6050_FS_SEL_2
#define MPU6050_FS_SEL_2000 MPU6050_FS_SEL_3
// ACCEL_CONFIG Register
// The XA_ST, YA_ST, ZA_ST are bits for selftest.
// The AFS_SEL sets the range for the accelerometer.
// These are the names for the bits.
// Use these only with the bit() macro.
#define MPU6050_ACCEL_HPF0 MPU6050_D0
#define MPU6050_ACCEL_HPF1 MPU6050_D1
#define MPU6050_ACCEL_HPF2 MPU6050_D2
#define MPU6050_AFS_SEL0 MPU6050_D3
#define MPU6050_AFS_SEL1 MPU6050_D4
#define MPU6050_ZA_ST MPU6050_D5
#define MPU6050_YA_ST MPU6050_D6
#define MPU6050_XA_ST MPU6050_D7
// Combined definitions for the ACCEL_HPF values
#define MPU6050_ACCEL_HPF_0 (0)
#define MPU6050_ACCEL_HPF_1 (bit(MPU6050_ACCEL_HPF0))
#define MPU6050_ACCEL_HPF_2 (bit(MPU6050_ACCEL_HPF1))
#define MPU6050_ACCEL_HPF_3 (bit(MPU6050_ACCEL_HPF1)|bit(MPU6050_ACCEL_HPF0))
#define MPU6050_ACCEL_HPF_4 (bit(MPU6050_ACCEL_HPF2))
#define MPU6050_ACCEL_HPF_7 (bit(MPU6050_ACCEL_HPF2)|bit(MPU6050_ACCEL_HPF1)|bit(MPU6050_ACCEL_HPF0))
// Alternative names for the combined definitions
// The name uses the Cut-off frequency.
#define MPU6050_ACCEL_HPF_RESET MPU6050_ACCEL_HPF_0
#define MPU6050_ACCEL_HPF_5HZ MPU6050_ACCEL_HPF_1
#define MPU6050_ACCEL_HPF_2_5HZ MPU6050_ACCEL_HPF_2
#define MPU6050_ACCEL_HPF_1_25HZ MPU6050_ACCEL_HPF_3
#define MPU6050_ACCEL_HPF_0_63HZ MPU6050_ACCEL_HPF_4
#define MPU6050_ACCEL_HPF_HOLD MPU6050_ACCEL_HPF_7
// Combined definitions for the AFS_SEL values
#define MPU6050_AFS_SEL_0 (0)
#define MPU6050_AFS_SEL_1 (bit(MPU6050_AFS_SEL0))
#define MPU6050_AFS_SEL_2 (bit(MPU6050_AFS_SEL1))
#define MPU6050_AFS_SEL_3 (bit(MPU6050_AFS_SEL1)|bit(MPU6050_AFS_SEL0))
// Alternative names for the combined definitions
// The name uses the full scale range for the accelerometer.
#define MPU6050_AFS_SEL_2G MPU6050_AFS_SEL_0
#define MPU6050_AFS_SEL_4G MPU6050_AFS_SEL_1
#define MPU6050_AFS_SEL_8G MPU6050_AFS_SEL_2
#define MPU6050_AFS_SEL_16G MPU6050_AFS_SEL_3
// FIFO_EN Register
// These are the names for the bits.
// Use these only with the bit() macro.
#define MPU6050_SLV0_FIFO_EN MPU6050_D0
#define MPU6050_SLV1_FIFO_EN MPU6050_D1
#define MPU6050_SLV2_FIFO_EN MPU6050_D2
#define MPU6050_ACCEL_FIFO_EN MPU6050_D3
#define MPU6050_ZG_FIFO_EN MPU6050_D4
#define MPU6050_YG_FIFO_EN MPU6050_D5
#define MPU6050_XG_FIFO_EN MPU6050_D6
#define MPU6050_TEMP_FIFO_EN MPU6050_D7
// I2C_MST_CTRL Register
// These are the names for the bits.
// Use these only with the bit() macro.
#define MPU6050_I2C_MST_CLK0 MPU6050_D0
#define MPU6050_I2C_MST_CLK1 MPU6050_D1
#define MPU6050_I2C_MST_CLK2 MPU6050_D2
#define MPU6050_I2C_MST_CLK3 MPU6050_D3
#define MPU6050_I2C_MST_P_NSR MPU6050_D4
#define MPU6050_SLV_3_FIFO_EN MPU6050_D5
#define MPU6050_WAIT_FOR_ES MPU6050_D6
#define MPU6050_MULT_MST_EN MPU6050_D7
// Combined definitions for the I2C_MST_CLK
#define MPU6050_I2C_MST_CLK_0 (0)
#define MPU6050_I2C_MST_CLK_1 (bit(MPU6050_I2C_MST_CLK0))
#define MPU6050_I2C_MST_CLK_2 (bit(MPU6050_I2C_MST_CLK1))
#define MPU6050_I2C_MST_CLK_3 (bit(MPU6050_I2C_MST_CLK1)|bit(MPU6050_I2C_MST_CLK0))
#define MPU6050_I2C_MST_CLK_4 (bit(MPU6050_I2C_MST_CLK2))
#define MPU6050_I2C_MST_CLK_5 (bit(MPU6050_I2C_MST_CLK2)|bit(MPU6050_I2C_MST_CLK0))
#define MPU6050_I2C_MST_CLK_6 (bit(MPU6050_I2C_MST_CLK2)|bit(MPU6050_I2C_MST_CLK1))
#define MPU6050_I2C_MST_CLK_7 (bit(MPU6050_I2C_MST_CLK2)|bit(MPU6050_I2C_MST_CLK1)|bit(MPU6050_I2C_MST_CLK0))
#define MPU6050_I2C_MST_CLK_8 (bit(MPU6050_I2C_MST_CLK3))
#define MPU6050_I2C_MST_CLK_9 (bit(MPU6050_I2C_MST_CLK3)|bit(MPU6050_I2C_MST_CLK0))
#define MPU6050_I2C_MST_CLK_10 (bit(MPU6050_I2C_MST_CLK3)|bit(MPU6050_I2C_MST_CLK1))
#define MPU6050_I2C_MST_CLK_11 (bit(MPU6050_I2C_MST_CLK3)|bit(MPU6050_I2C_MST_CLK1)|bit(MPU6050_I2C_MST_CLK0))
#define MPU6050_I2C_MST_CLK_12 (bit(MPU6050_I2C_MST_CLK3)|bit(MPU6050_I2C_MST_CLK2))
#define MPU6050_I2C_MST_CLK_13 (bit(MPU6050_I2C_MST_CLK3)|bit(MPU6050_I2C_MST_CLK2)|bit(MPU6050_I2C_MST_CLK0))
#define MPU6050_I2C_MST_CLK_14 (bit(MPU6050_I2C_MST_CLK3)|bit(MPU6050_I2C_MST_CLK2)|bit(MPU6050_I2C_MST_CLK1))
#define MPU6050_I2C_MST_CLK_15 (bit(MPU6050_I2C_MST_CLK3)|bit(MPU6050_I2C_MST_CLK2)|bit(MPU6050_I2C_MST_CLK1)|bit(MPU6050_I2C_MST_CLK0))
// Alternative names for the combined definitions
// The names uses I2C Master Clock Speed in kHz.
#define MPU6050_I2C_MST_CLK_348KHZ MPU6050_I2C_MST_CLK_0
#define MPU6050_I2C_MST_CLK_333KHZ MPU6050_I2C_MST_CLK_1
#define MPU6050_I2C_MST_CLK_320KHZ MPU6050_I2C_MST_CLK_2
#define MPU6050_I2C_MST_CLK_308KHZ MPU6050_I2C_MST_CLK_3
#define MPU6050_I2C_MST_CLK_296KHZ MPU6050_I2C_MST_CLK_4
#define MPU6050_I2C_MST_CLK_286KHZ MPU6050_I2C_MST_CLK_5
#define MPU6050_I2C_MST_CLK_276KHZ MPU6050_I2C_MST_CLK_6
#define MPU6050_I2C_MST_CLK_267KHZ MPU6050_I2C_MST_CLK_7
#define MPU6050_I2C_MST_CLK_258KHZ MPU6050_I2C_MST_CLK_8
#define MPU6050_I2C_MST_CLK_500KHZ MPU6050_I2C_MST_CLK_9
#define MPU6050_I2C_MST_CLK_471KHZ MPU6050_I2C_MST_CLK_10
#define MPU6050_I2C_MST_CLK_444KHZ MPU6050_I2C_MST_CLK_11
#define MPU6050_I2C_MST_CLK_421KHZ MPU6050_I2C_MST_CLK_12
#define MPU6050_I2C_MST_CLK_400KHZ MPU6050_I2C_MST_CLK_13
#define MPU6050_I2C_MST_CLK_381KHZ MPU6050_I2C_MST_CLK_14
#define MPU6050_I2C_MST_CLK_364KHZ MPU6050_I2C_MST_CLK_15
// I2C_SLV0_ADDR Register
// These are the names for the bits.
// Use these only with the bit() macro.
#define MPU6050_I2C_SLV0_RW MPU6050_D7
// I2C_SLV0_CTRL Register
// These are the names for the bits.
// Use these only with the bit() macro.
#define MPU6050_I2C_SLV0_LEN0 MPU6050_D0
#define MPU6050_I2C_SLV0_LEN1 MPU6050_D1
#define MPU6050_I2C_SLV0_LEN2 MPU6050_D2
#define MPU6050_I2C_SLV0_LEN3 MPU6050_D3
#define MPU6050_I2C_SLV0_GRP MPU6050_D4
#define MPU6050_I2C_SLV0_REG_DIS MPU6050_D5
#define MPU6050_I2C_SLV0_BYTE_SW MPU6050_D6
#define MPU6050_I2C_SLV0_EN MPU6050_D7
// A mask for the length
#define MPU6050_I2C_SLV0_LEN_MASK 0x0F
// I2C_SLV1_ADDR Register
// These are the names for the bits.
// Use these only with the bit() macro.
#define MPU6050_I2C_SLV1_RW MPU6050_D7
// I2C_SLV1_CTRL Register
// These are the names for the bits.
// Use these only with the bit() macro.
#define MPU6050_I2C_SLV1_LEN0 MPU6050_D0
#define MPU6050_I2C_SLV1_LEN1 MPU6050_D1
#define MPU6050_I2C_SLV1_LEN2 MPU6050_D2
#define MPU6050_I2C_SLV1_LEN3 MPU6050_D3
#define MPU6050_I2C_SLV1_GRP MPU6050_D4
#define MPU6050_I2C_SLV1_REG_DIS MPU6050_D5
#define MPU6050_I2C_SLV1_BYTE_SW MPU6050_D6
#define MPU6050_I2C_SLV1_EN MPU6050_D7
// A mask for the length
#define MPU6050_I2C_SLV1_LEN_MASK 0x0F
// I2C_SLV2_ADDR Register
// These are the names for the bits.
// Use these only with the bit() macro.
#define MPU6050_I2C_SLV2_RW MPU6050_D7
// I2C_SLV2_CTRL Register
// These are the names for the bits.
// Use these only with the bit() macro.
#define MPU6050_I2C_SLV2_LEN0 MPU6050_D0
#define MPU6050_I2C_SLV2_LEN1 MPU6050_D1
#define MPU6050_I2C_SLV2_LEN2 MPU6050_D2
#define MPU6050_I2C_SLV2_LEN3 MPU6050_D3
#define MPU6050_I2C_SLV2_GRP MPU6050_D4
#define MPU6050_I2C_SLV2_REG_DIS MPU6050_D5
#define MPU6050_I2C_SLV2_BYTE_SW MPU6050_D6
#define MPU6050_I2C_SLV2_EN MPU6050_D7
// A mask for the length
#define MPU6050_I2C_SLV2_LEN_MASK 0x0F
// I2C_SLV3_ADDR Register
// These are the names for the bits.
// Use these only with the bit() macro.
#define MPU6050_I2C_SLV3_RW MPU6050_D7
// I2C_SLV3_CTRL Register
// These are the names for the bits.
// Use these only with the bit() macro.
#define MPU6050_I2C_SLV3_LEN0 MPU6050_D0
#define MPU6050_I2C_SLV3_LEN1 MPU6050_D1
#define MPU6050_I2C_SLV3_LEN2 MPU6050_D2
#define MPU6050_I2C_SLV3_LEN3 MPU6050_D3
#define MPU6050_I2C_SLV3_GRP MPU6050_D4
#define MPU6050_I2C_SLV3_REG_DIS MPU6050_D5
#define MPU6050_I2C_SLV3_BYTE_SW MPU6050_D6
#define MPU6050_I2C_SLV3_EN MPU6050_D7
// A mask for the length
#define MPU6050_I2C_SLV3_LEN_MASK 0x0F
// I2C_SLV4_ADDR Register
// These are the names for the bits.
// Use these only with the bit() macro.
#define MPU6050_I2C_SLV4_RW MPU6050_D7
// I2C_SLV4_CTRL Register
// These are the names for the bits.
// Use these only with the bit() macro.
#define MPU6050_I2C_MST_DLY0 MPU6050_D0
#define MPU6050_I2C_MST_DLY1 MPU6050_D1
#define MPU6050_I2C_MST_DLY2 MPU6050_D2
#define MPU6050_I2C_MST_DLY3 MPU6050_D3
#define MPU6050_I2C_MST_DLY4 MPU6050_D4
#define MPU6050_I2C_SLV4_REG_DIS MPU6050_D5
#define MPU6050_I2C_SLV4_INT_EN MPU6050_D6
#define MPU6050_I2C_SLV4_EN MPU6050_D7
// A mask for the delay
#define MPU6050_I2C_MST_DLY_MASK 0x1F
// I2C_MST_STATUS Register
// These are the names for the bits.
// Use these only with the bit() macro.
#define MPU6050_I2C_SLV0_NACK MPU6050_D0
#define MPU6050_I2C_SLV1_NACK MPU6050_D1
#define MPU6050_I2C_SLV2_NACK MPU6050_D2
#define MPU6050_I2C_SLV3_NACK MPU6050_D3
#define MPU6050_I2C_SLV4_NACK MPU6050_D4
#define MPU6050_I2C_LOST_ARB MPU6050_D5
#define MPU6050_I2C_SLV4_DONE MPU6050_D6
#define MPU6050_PASS_THROUGH MPU6050_D7
// I2C_PIN_CFG Register
// These are the names for the bits.
// Use these only with the bit() macro.
#define MPU6050_CLKOUT_EN MPU6050_D0
#define MPU6050_I2C_BYPASS_EN MPU6050_D1
#define MPU6050_FSYNC_INT_EN MPU6050_D2
#define MPU6050_FSYNC_INT_LEVEL MPU6050_D3
#define MPU6050_INT_RD_CLEAR MPU6050_D4
#define MPU6050_LATCH_INT_EN MPU6050_D5
#define MPU6050_INT_OPEN MPU6050_D6
#define MPU6050_INT_LEVEL MPU6050_D7
// INT_ENABLE Register
// These are the names for the bits.
// Use these only with the bit() macro.
#define MPU6050_DATA_RDY_EN MPU6050_D0
#define MPU6050_I2C_MST_INT_EN MPU6050_D3
#define MPU6050_FIFO_OFLOW_EN MPU6050_D4
#define MPU6050_ZMOT_EN MPU6050_D5
#define MPU6050_MOT_EN MPU6050_D6
#define MPU6050_FF_EN MPU6050_D7
// INT_STATUS Register
// These are the names for the bits.
// Use these only with the bit() macro.
#define MPU6050_DATA_RDY_INT MPU6050_D0
#define MPU6050_I2C_MST_INT MPU6050_D3
#define MPU6050_FIFO_OFLOW_INT MPU6050_D4
#define MPU6050_ZMOT_INT MPU6050_D5
#define MPU6050_MOT_INT MPU6050_D6
#define MPU6050_FF_INT MPU6050_D7
// MOT_DETECT_STATUS Register
// These are the names for the bits.
// Use these only with the bit() macro.
#define MPU6050_MOT_ZRMOT MPU6050_D0
#define MPU6050_MOT_ZPOS MPU6050_D2
#define MPU6050_MOT_ZNEG MPU6050_D3
#define MPU6050_MOT_YPOS MPU6050_D4
#define MPU6050_MOT_YNEG MPU6050_D5
#define MPU6050_MOT_XPOS MPU6050_D6
#define MPU6050_MOT_XNEG MPU6050_D7
// IC2_MST_DELAY_CTRL Register
// These are the names for the bits.
// Use these only with the bit() macro.
#define MPU6050_I2C_SLV0_DLY_EN MPU6050_D0
#define MPU6050_I2C_SLV1_DLY_EN MPU6050_D1
#define MPU6050_I2C_SLV2_DLY_EN MPU6050_D2
#define MPU6050_I2C_SLV3_DLY_EN MPU6050_D3
#define MPU6050_I2C_SLV4_DLY_EN MPU6050_D4
#define MPU6050_DELAY_ES_SHADOW MPU6050_D7
// SIGNAL_PATH_RESET Register
// These are the names for the bits.
// Use these only with the bit() macro.
#define MPU6050_TEMP_RESET MPU6050_D0
#define MPU6050_ACCEL_RESET MPU6050_D1
#define MPU6050_GYRO_RESET MPU6050_D2
// MOT_DETECT_CTRL Register
// These are the names for the bits.
// Use these only with the bit() macro.
#define MPU6050_MOT_COUNT0 MPU6050_D0
#define MPU6050_MOT_COUNT1 MPU6050_D1
#define MPU6050_FF_COUNT0 MPU6050_D2
#define MPU6050_FF_COUNT1 MPU6050_D3
#define MPU6050_ACCEL_ON_DELAY0 MPU6050_D4
#define MPU6050_ACCEL_ON_DELAY1 MPU6050_D5
// Combined definitions for the MOT_COUNT
#define MPU6050_MOT_COUNT_0 (0)
#define MPU6050_MOT_COUNT_1 (bit(MPU6050_MOT_COUNT0))
#define MPU6050_MOT_COUNT_2 (bit(MPU6050_MOT_COUNT1))
#define MPU6050_MOT_COUNT_3 (bit(MPU6050_MOT_COUNT1)|bit(MPU6050_MOT_COUNT0))
// Alternative names for the combined definitions
#define MPU6050_MOT_COUNT_RESET MPU6050_MOT_COUNT_0
// Combined definitions for the FF_COUNT
#define MPU6050_FF_COUNT_0 (0)
#define MPU6050_FF_COUNT_1 (bit(MPU6050_FF_COUNT0))
#define MPU6050_FF_COUNT_2 (bit(MPU6050_FF_COUNT1))
#define MPU6050_FF_COUNT_3 (bit(MPU6050_FF_COUNT1)|bit(MPU6050_FF_COUNT0))
// Alternative names for the combined definitions
#define MPU6050_FF_COUNT_RESET MPU6050_FF_COUNT_0
// Combined definitions for the ACCEL_ON_DELAY
#define MPU6050_ACCEL_ON_DELAY_0 (0)
#define MPU6050_ACCEL_ON_DELAY_1 (bit(MPU6050_ACCEL_ON_DELAY0))
#define MPU6050_ACCEL_ON_DELAY_2 (bit(MPU6050_ACCEL_ON_DELAY1))
#define MPU6050_ACCEL_ON_DELAY_3 (bit(MPU6050_ACCEL_ON_DELAY1)|bit(MPU6050_ACCEL_ON_DELAY0))
// Alternative names for the ACCEL_ON_DELAY
#define MPU6050_ACCEL_ON_DELAY_0MS MPU6050_ACCEL_ON_DELAY_0
#define MPU6050_ACCEL_ON_DELAY_1MS MPU6050_ACCEL_ON_DELAY_1
#define MPU6050_ACCEL_ON_DELAY_2MS MPU6050_ACCEL_ON_DELAY_2
#define MPU6050_ACCEL_ON_DELAY_3MS MPU6050_ACCEL_ON_DELAY_3
// USER_CTRL Register
// These are the names for the bits.
// Use these only with the bit() macro.
#define MPU6050_SIG_COND_RESET MPU6050_D0
#define MPU6050_I2C_MST_RESET MPU6050_D1
#define MPU6050_FIFO_RESET MPU6050_D2
#define MPU6050_I2C_IF_DIS MPU6050_D4 // must be 0 for MPU-6050
#define MPU6050_I2C_MST_EN MPU6050_D5
#define MPU6050_FIFO_EN MPU6050_D6
// PWR_MGMT_1 Register
// These are the names for the bits.
// Use these only with the bit() macro.
#define MPU6050_CLKSEL0 MPU6050_D0
#define MPU6050_CLKSEL1 MPU6050_D1
#define MPU6050_CLKSEL2 MPU6050_D2
#define MPU6050_TEMP_DIS MPU6050_D3 // 1: disable temperature sensor
#define MPU6050_CYCLE MPU6050_D5 // 1: sample and sleep
#define MPU6050_SLEEP MPU6050_D6 // 1: sleep mode
#define MPU6050_DEVICE_RESET MPU6050_D7 // 1: reset to default values
// Combined definitions for the CLKSEL
#define MPU6050_CLKSEL_0 (0)
#define MPU6050_CLKSEL_1 (bit(MPU6050_CLKSEL0))
#define MPU6050_CLKSEL_2 (bit(MPU6050_CLKSEL1))
#define MPU6050_CLKSEL_3 (bit(MPU6050_CLKSEL1)|bit(MPU6050_CLKSEL0))
#define MPU6050_CLKSEL_4 (bit(MPU6050_CLKSEL2))
#define MPU6050_CLKSEL_5 (bit(MPU6050_CLKSEL2)|bit(MPU6050_CLKSEL0))
#define MPU6050_CLKSEL_6 (bit(MPU6050_CLKSEL2)|bit(MPU6050_CLKSEL1))
#define MPU6050_CLKSEL_7 (bit(MPU6050_CLKSEL2)|bit(MPU6050_CLKSEL1)|bit(MPU6050_CLKSEL0))
// Alternative names for the combined definitions
#define MPU6050_CLKSEL_INTERNAL MPU6050_CLKSEL_0
#define MPU6050_CLKSEL_X MPU6050_CLKSEL_1
#define MPU6050_CLKSEL_Y MPU6050_CLKSEL_2
#define MPU6050_CLKSEL_Z MPU6050_CLKSEL_3
#define MPU6050_CLKSEL_EXT_32KHZ MPU6050_CLKSEL_4
#define MPU6050_CLKSEL_EXT_19_2MHZ MPU6050_CLKSEL_5
#define MPU6050_CLKSEL_RESERVED MPU6050_CLKSEL_6
#define MPU6050_CLKSEL_STOP MPU6050_CLKSEL_7
// PWR_MGMT_2 Register
// These are the names for the bits.
// Use these only with the bit() macro.
#define MPU6050_STBY_ZG MPU6050_D0
#define MPU6050_STBY_YG MPU6050_D1
#define MPU6050_STBY_XG MPU6050_D2
#define MPU6050_STBY_ZA MPU6050_D3
#define MPU6050_STBY_YA MPU6050_D4
#define MPU6050_STBY_XA MPU6050_D5
#define MPU6050_LP_WAKE_CTRL0 MPU6050_D6
#define MPU6050_LP_WAKE_CTRL1 MPU6050_D7
// Combined definitions for the LP_WAKE_CTRL
#define MPU6050_LP_WAKE_CTRL_0 (0)
#define MPU6050_LP_WAKE_CTRL_1 (bit(MPU6050_LP_WAKE_CTRL0))
#define MPU6050_LP_WAKE_CTRL_2 (bit(MPU6050_LP_WAKE_CTRL1))
#define MPU6050_LP_WAKE_CTRL_3 (bit(MPU6050_LP_WAKE_CTRL1)|bit(MPU6050_LP_WAKE_CTRL0))
// Alternative names for the combined definitions
// The names uses the Wake-up Frequency.
#define MPU6050_LP_WAKE_1_25HZ MPU6050_LP_WAKE_CTRL_0
#define MPU6050_LP_WAKE_2_5HZ MPU6050_LP_WAKE_CTRL_1
#define MPU6050_LP_WAKE_5HZ MPU6050_LP_WAKE_CTRL_2
#define MPU6050_LP_WAKE_10HZ MPU6050_LP_WAKE_CTRL_3
// Default I2C address for the MPU-6050 is 0x68.
// But only if the AD0 pin is low.
// Some sensor boards have AD0 high, and the
// I2C address thus becomes 0x69.
#define MPU6050_I2C_ADDRESS 0x68
// Declaring an union for the registers and the axis values.
// The byte order does not match the byte order of
// the compiler and AVR chip.
// The AVR chip (on the Arduino board) has the Low Byte
// at the lower address.
// But the MPU-6050 has a different order: High Byte at
// lower address, so that has to be corrected.
// The register part "reg" is only used internally,
// and are swapped in code.
typedef union accel_t_gyro_union
{
struct
{
uint8_t x_accel_h;
uint8_t x_accel_l;
uint8_t y_accel_h;
uint8_t y_accel_l;
uint8_t z_accel_h;
uint8_t z_accel_l;
uint8_t t_h;
uint8_t t_l;
uint8_t x_gyro_h;
uint8_t x_gyro_l;
uint8_t y_gyro_h;
uint8_t y_gyro_l;
uint8_t z_gyro_h;
uint8_t z_gyro_l;
} reg;
struct
{
int x_accel;
int y_accel;
int z_accel;
int temperature;
int x_gyro;
int y_gyro;
int z_gyro;
} value;
};
// Use the following global variables and access functions to help store the overall
// rotation angle of the sensor
unsigned long last_read_time;
float last_x_angle; // These are the filtered angles
float last_y_angle;
float last_z_angle;
float last_gyro_x_angle; // Store the gyro angles to compare drift
float last_gyro_y_angle;
float last_gyro_z_angle;
void set_last_read_angle_data(unsigned long time, float x, float y, float z, float x_gyro, float y_gyro, float z_gyro) {
last_read_time = time;
last_x_angle = x;
last_y_angle = y;
last_z_angle = z;
last_gyro_x_angle = x_gyro;
last_gyro_y_angle = y_gyro;
last_gyro_z_angle = z_gyro;
}
inline unsigned long get_last_time() {
return last_read_time;
}
inline float get_last_x_angle() {
return last_x_angle;
}
inline float get_last_y_angle() {
return last_y_angle;
}
inline float get_last_z_angle() {
return last_z_angle;
}
inline float get_last_gyro_x_angle() {
return last_gyro_x_angle;
}
inline float get_last_gyro_y_angle() {
return last_gyro_y_angle;
}
inline float get_last_gyro_z_angle() {
return last_gyro_z_angle;
}
// Use the following global variables and access functions
// to calibrate the acceleration sensor
float base_x_accel;
float base_y_accel;
float base_z_accel;
float base_x_gyro;
float base_y_gyro;
float base_z_gyro;
int read_gyro_accel_vals(uint8_t* accel_t_gyro_ptr) {
// Read the raw values.
// Read 14 bytes at once,
// containing acceleration, temperature and gyro.
// With the default settings of the MPU-6050,
// there is no filter enabled, and the values
// are not very stable. Returns the error value
accel_t_gyro_union* accel_t_gyro = (accel_t_gyro_union *) accel_t_gyro_ptr;
int error = MPU6050_read (MPU6050_ACCEL_XOUT_H, (uint8_t *) accel_t_gyro, sizeof(*accel_t_gyro));
// Swap all high and low bytes.
// After this, the registers values are swapped,
// so the structure name like x_accel_l does no
// longer contain the lower byte.
uint8_t swap;
#define SWAP(x,y) swap = x; x = y; y = swap
SWAP ((*accel_t_gyro).reg.x_accel_h, (*accel_t_gyro).reg.x_accel_l);
SWAP ((*accel_t_gyro).reg.y_accel_h, (*accel_t_gyro).reg.y_accel_l);
SWAP ((*accel_t_gyro).reg.z_accel_h, (*accel_t_gyro).reg.z_accel_l);
SWAP ((*accel_t_gyro).reg.t_h, (*accel_t_gyro).reg.t_l);
SWAP ((*accel_t_gyro).reg.x_gyro_h, (*accel_t_gyro).reg.x_gyro_l);
SWAP ((*accel_t_gyro).reg.y_gyro_h, (*accel_t_gyro).reg.y_gyro_l);
SWAP ((*accel_t_gyro).reg.z_gyro_h, (*accel_t_gyro).reg.z_gyro_l);
return error;
}
// The sensor should be motionless on a horizontal surface
// while calibration is happening
void calibrate_sensors() {
int num_readings = 10;
float x_accel = 0;
float y_accel = 0;
float z_accel = 0;
float x_gyro = 0;
float y_gyro = 0;
float z_gyro = 0;
accel_t_gyro_union accel_t_gyro;
//Serial.println("Starting Calibration");
// Discard the first set of values read from the IMU
read_gyro_accel_vals((uint8_t *) &accel_t_gyro);
// Read and average the raw values from the IMU
for (int i = 0; i < num_readings; i++) {
read_gyro_accel_vals((uint8_t *) &accel_t_gyro);
x_accel += accel_t_gyro.value.x_accel;
y_accel += accel_t_gyro.value.y_accel;
z_accel += accel_t_gyro.value.z_accel;
x_gyro += accel_t_gyro.value.x_gyro;
y_gyro += accel_t_gyro.value.y_gyro;
z_gyro += accel_t_gyro.value.z_gyro;
delay(100);
}
x_accel /= num_readings;
y_accel /= num_readings;
z_accel /= num_readings;
x_gyro /= num_readings;
y_gyro /= num_readings;
z_gyro /= num_readings;
// Store the raw calibration values globally
base_x_accel = x_accel;
base_y_accel = y_accel;
base_z_accel = z_accel;
base_x_gyro = x_gyro;
base_y_gyro = y_gyro;
base_z_gyro = z_gyro;
//Serial.println("Finishing Calibration");
}
void setup()
{
int error;
uint8_t c;
Serial.begin(9600);
/*
Serial.println(F("InvenSense MPU-6050"));
Serial.println(F("June 2012"));
*/
// Initialize the 'Wire' class for the I2C-bus.
Wire.begin();
// default at power-up:
// Gyro at 250 degrees second
// Acceleration at 2g
// Clock source at internal 8MHz
// The device is in sleep mode.
//
error = MPU6050_read (MPU6050_WHO_AM_I, &c, 1);
/*
Serial.print(F("WHO_AM_I : "));
Serial.print(c,HEX);
Serial.print(F(", error = "));
Serial.println(error,DEC);
*/
// According to the datasheet, the 'sleep' bit
// should read a '1'. But I read a '0'.
// That bit has to be cleared, since the sensor
// is in sleep mode at power-up. Even if the
// bit reads '0'.
error = MPU6050_read (MPU6050_PWR_MGMT_2, &c, 1);
/*
Serial.print(F("PWR_MGMT_2 : "));
Serial.print(c,HEX);
Serial.print(F(", error = "));
Serial.println(error,DEC);
*/
// Clear the 'sleep' bit to start the sensor.
MPU6050_write_reg (MPU6050_PWR_MGMT_1, 0);
//Initialize the angles
calibrate_sensors();
set_last_read_angle_data(millis(), 0, 0, 0, 0, 0, 0);
}
void loop()
{
int error;
double dT;
accel_t_gyro_union accel_t_gyro;
/*
Serial.println(F(""));
Serial.println(F("MPU-6050"));
*/
// Read the raw values.
error = read_gyro_accel_vals((uint8_t*) &accel_t_gyro);
// Get the time of reading for rotation computations
unsigned long t_now = millis();
/*
Serial.print(F("Read accel, temp and gyro, error = "));
Serial.println(error,DEC);
// Print the raw acceleration values
Serial.print(F("accel x,y,z: "));
Serial.print(accel_t_gyro.value.x_accel, DEC);
Serial.print(F(", "));
Serial.print(accel_t_gyro.value.y_accel, DEC);
Serial.print(F(", "));
Serial.print(accel_t_gyro.value.z_accel, DEC);
Serial.println(F(""));
*/
// The temperature sensor is -40 to +85 degrees Celsius.
// It is a signed integer.
// According to the datasheet:
// 340 per degrees Celsius, -512 at 35 degrees.
// At 0 degrees: -512 - (340 * 35) = -12412
/*
Serial.print(F("temperature: "));
dT = ( (double) accel_t_gyro.value.temperature + 12412.0) / 340.0;
Serial.print(dT, 3);
Serial.print(F(" degrees Celsius"));
Serial.println(F(""));
// Print the raw gyro values.
Serial.print(F("raw gyro x,y,z : "));
Serial.print(accel_t_gyro.value.x_gyro, DEC);
Serial.print(F(", "));
Serial.print(accel_t_gyro.value.y_gyro, DEC);
Serial.print(F(", "));
Serial.print(accel_t_gyro.value.z_gyro, DEC);
Serial.print(F(", "));
Serial.println(F(""));
*/
// Convert gyro values to degrees/sec
float FS_SEL = 131;
/*
float gyro_x = (accel_t_gyro.value.x_gyro - base_x_gyro)/FS_SEL;
float gyro_y = (accel_t_gyro.value.y_gyro - base_y_gyro)/FS_SEL;
float gyro_z = (accel_t_gyro.value.z_gyro - base_z_gyro)/FS_SEL;
*/
float gyro_x = (accel_t_gyro.value.x_gyro - base_x_gyro) / FS_SEL;
float gyro_y = (accel_t_gyro.value.y_gyro - base_y_gyro) / FS_SEL;
float gyro_z = (accel_t_gyro.value.z_gyro - base_z_gyro) / FS_SEL;
// Get raw acceleration values
//float G_CONVERT = 16384;
float accel_x = accel_t_gyro.value.x_accel;
float accel_y = accel_t_gyro.value.y_accel;
float accel_z = accel_t_gyro.value.z_accel;
// Get angle values from accelerometer
float RADIANS_TO_DEGREES = 180 / 3.14159;
// float accel_vector_length = sqrt(pow(accel_x,2) + pow(accel_y,2) + pow(accel_z,2));
float accel_angle_y = atan(-1 * accel_x / sqrt(pow(accel_y, 2) + pow(accel_z, 2))) * RADIANS_TO_DEGREES;
float accel_angle_x = atan(accel_y / sqrt(pow(accel_x, 2) + pow(accel_z, 2))) * RADIANS_TO_DEGREES;
float accel_angle_z = 0;
// Compute the (filtered) gyro angles
float dt = (t_now - get_last_time()) / 1000.0;
float gyro_angle_x = gyro_x * dt + get_last_x_angle();
float gyro_angle_y = gyro_y * dt + get_last_y_angle();
float gyro_angle_z = gyro_z * dt + get_last_z_angle();
// Compute the drifting gyro angles
float unfiltered_gyro_angle_x = gyro_x * dt + get_last_gyro_x_angle();
float unfiltered_gyro_angle_y = gyro_y * dt + get_last_gyro_y_angle();
float unfiltered_gyro_angle_z = gyro_z * dt + get_last_gyro_z_angle();
// Apply the complementary filter to figure out the change in angle - choice of alpha is
// estimated now. Alpha depends on the sampling rate...
float alpha = 0.96;
float angle_x = alpha * gyro_angle_x + (1.0 - alpha) * accel_angle_x;
float angle_y = alpha * gyro_angle_y + (1.0 - alpha) * accel_angle_y;
float angle_z = gyro_angle_z; //Accelerometer doesn't give z-angle
// Update the saved data with the latest values
set_last_read_angle_data(t_now, angle_x, angle_y, angle_z, unfiltered_gyro_angle_x, unfiltered_gyro_angle_y, unfiltered_gyro_angle_z);
if (calibrationTimes == 0) {
delay(1000);
//Serial.println("Custom calibration start");
calibrationTimes++;
} else if (calibrationTimes < customCalibrationTime) {
if (accel_angle_x > maxAccValue) {
maxAccValue = accel_angle_x;
//Serial.print("New max Value: ");
//Serial.println(maxAccValue);
} else if (accel_angle_x < minAccValue) {
minAccValue = accel_angle_x;
//Serial.print("New min Value: ");
//Serial.println(minAccValue);
}
calibrationTimes++;
// Delay so we don't swamp the serial port
delay(50);
} else if (calibrationTimes == customCalibrationTime) {
zeroAccCalValue = (maxAccValue + minAccValue) / 2;
//Serial.println("Zero point: ");
//Serial.println(zeroAccCalValue);
//Serial.println("Custom calibration finished");
calibrationTimes++;
} else {
float temp = 0;
if (accel_angle_x < maxAccValue && accel_angle_x > minAccValue) {
temp = 0.00;
} else if (zeroAccCalValue < 0) {
temp = accel_angle_x - zeroAccCalValue;
} else {
temp = accel_angle_x + zeroAccCalValue;
}
v = v + (temp / 9.8);
// Serial.print("RawValue: ");
// Serial.print(accel_angle_x, 2);
Serial.print(" - CalValue: ");
Serial.print(temp, 2);
Serial.print(" - Velocity: ");
Serial.println(v);
delay(1);
}
// Send the data to the serial port
// Serial.print(F("DEL:")); //Delta T
// Serial.print(dt, DEC);
// Serial.print(F("#ACC:")); //Accelerometer angle
//Serial.println(accel_angle_x, 2);
// Serial.print(F(","));
// Serial.print(accel_angle_y, 2);
// Serial.print(F(","));
// Serial.print(accel_angle_z, 2);
// Serial.print(F("#GYR:"));
// Serial.print(unfiltered_gyro_angle_x, 2); //Gyroscope angle
// Serial.print(F(","));
// Serial.print(unfiltered_gyro_angle_y, 2);
// Serial.print(F(","));
// Serial.print(unfiltered_gyro_angle_z, 2);
// Serial.print(F("#FIL:")); //Filtered angle
// Serial.print(angle_x, 2);
// Serial.print(F(","));
// Serial.print(angle_y, 2);
// Serial.print(F(","));
// Serial.print(angle_z, 2);
// Serial.println(F(""));
}
// --------------------------------------------------------
// MPU6050_read
//
// This is a common function to read multiple bytes
// from an I2C device.
//
// It uses the boolean parameter for Wire.endTransMission()
// to be able to hold or release the I2C-bus.
// This is implemented in Arduino 1.0.1.
//
// Only this function is used to read.
// There is no function for a single byte.
//
int MPU6050_read(int start, uint8_t *buffer, int size)
{
int i, n, error;
Wire.beginTransmission(MPU6050_I2C_ADDRESS);
n = Wire.write(start);
if (n != 1)
return (-10);
n = Wire.endTransmission(false); // hold the I2C-bus
if (n != 0)
return (n);
// Third parameter is true: relase I2C-bus after data is read.
Wire.requestFrom(MPU6050_I2C_ADDRESS, size, true);
i = 0;
while (Wire.available() && i < size)
{
buffer[i++] = Wire.read();
}
if ( i != size)
return (-11);
return (0); // return : no error
}
// --------------------------------------------------------
// MPU6050_write
//
// This is a common function to write multiple bytes to an I2C device.
//
// If only a single register is written,
// use the function MPU_6050_write_reg().
//
// Parameters:
// start : Start address, use a define for the register
// pData : A pointer to the data to write.
// size : The number of bytes to write.
//
// If only a single register is written, a pointer
// to the data has to be used, and the size is
// a single byte:
// int data = 0; // the data to write
// MPU6050_write (MPU6050_PWR_MGMT_1, &c, 1);
//
int MPU6050_write(int start, const uint8_t *pData, int size)
{
int n, error;
Wire.beginTransmission(MPU6050_I2C_ADDRESS);
n = Wire.write(start); // write the start address
if (n != 1)
return (-20);
n = Wire.write(pData, size); // write data bytes
if (n != size)
return (-21);
error = Wire.endTransmission(true); // release the I2C-bus
if (error != 0)
return (error);
return (0); // return : no error
}
// --------------------------------------------------------
// MPU6050_write_reg
//
// An extra function to write a single register.
// It is just a wrapper around the MPU_6050_write()
// function, and it is only a convenient function
// to make it easier to write a single register.
//
int MPU6050_write_reg(int reg, uint8_t data)
{
int error;
error = MPU6050_write(reg, &data, 1);
return (error);
}
| [
"princebalabis@gmail.com"
] | princebalabis@gmail.com |
f88cdb7fc727566a868a3872e6deb53be217aba2 | 7ef30b45df7b84151cc03065e4184f93526468e2 | /Eclipse Cpp WS/BaseAndDerive/Base.h | e268eb9962a738767cee8ac480cbca826978dcca | [] | no_license | littlepretty/Eclipse-for-Cpp | 356eff5b6918e167fb7f2e7bc04086352e91e263 | b98a82f060014c1e99044d4ede74ae6a44427afb | refs/heads/master | 2016-09-05T16:17:03.776453 | 2013-04-25T02:57:29 | 2013-04-25T02:57:29 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 185 | h | /*
* Base.h
*
* Created on: 2012-5-2
* Author: pc5
*/
#ifndef BASE_H_
#define BASE_H_
class Base {
public:
Base();
virtual ~Base();
double x,y;
};
#endif /* BASE_H_ */
| [
"littlepretty881203@gmail.com"
] | littlepretty881203@gmail.com |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.