From 9964871e95534fec0b543854a875561443856d69 Mon Sep 17 00:00:00 2001 From: Adam Sylvester Date: Wed, 5 Aug 2015 18:49:58 -0400 Subject: [PATCH] Had missed adding template for DirectionParameters. Looked like AreaDirectionParameters was using wrong type. --- .../six.sicd/source/generated/six_sicd.py | 104 +- .../source/generated/six_sicd_wrap.cxx | 3543 +++++++++++++---- modules/python/six.sicd/source/six_sicd.i | 4 +- 3 files changed, 2812 insertions(+), 839 deletions(-) diff --git a/modules/python/six.sicd/source/generated/six_sicd.py b/modules/python/six.sicd/source/generated/six_sicd.py index 6851ac235..3be7a2f51 100644 --- a/modules/python/six.sicd/source/generated/six_sicd.py +++ b/modules/python/six.sicd/source/generated/six_sicd.py @@ -4761,8 +4761,104 @@ def capacity(self): VectorPolyXYZ_swigregister = _six_sicd.VectorPolyXYZ_swigregister VectorPolyXYZ_swigregister(VectorPolyXYZ) +class ScopedCloneableDirectionParameters(_object): + """Proxy of C++ mem::ScopedCloneablePtr<(six::sicd::DirectionParameters)> class""" + __swig_setmethods__ = {} + __setattr__ = lambda self, name, value: _swig_setattr(self, ScopedCloneableDirectionParameters, name, value) + __swig_getmethods__ = {} + __getattr__ = lambda self, name: _swig_getattr(self, ScopedCloneableDirectionParameters, name) + __repr__ = _swig_repr + + def __init__(self, *args): + """ + __init__(mem::ScopedCloneablePtr<(six::sicd::DirectionParameters)> self, DirectionParameters ptr=None) -> ScopedCloneableDirectionParameters + __init__(mem::ScopedCloneablePtr<(six::sicd::DirectionParameters)> self) -> ScopedCloneableDirectionParameters + __init__(mem::ScopedCloneablePtr<(six::sicd::DirectionParameters)> self, ScopedCloneableDirectionParameters rhs) -> ScopedCloneableDirectionParameters + """ + this = _six_sicd.new_ScopedCloneableDirectionParameters(*args) + try: + self.this.append(this) + except: + self.this = this + + def get(self): + """get(ScopedCloneableDirectionParameters self) -> DirectionParameters""" + return _six_sicd.ScopedCloneableDirectionParameters_get(self) + + + def __ref__(self): + """__ref__(ScopedCloneableDirectionParameters self) -> DirectionParameters""" + return _six_sicd.ScopedCloneableDirectionParameters___ref__(self) + + + def __deref__(self): + """__deref__(ScopedCloneableDirectionParameters self) -> DirectionParameters""" + return _six_sicd.ScopedCloneableDirectionParameters___deref__(self) + + + def reset(self, ptr=None): + """ + reset(ScopedCloneableDirectionParameters self, DirectionParameters ptr=None) + reset(ScopedCloneableDirectionParameters self) + """ + return _six_sicd.ScopedCloneableDirectionParameters_reset(self, ptr) + + __swig_destroy__ = _six_sicd.delete_ScopedCloneableDirectionParameters + __del__ = lambda self: None + + def clone(self): + """clone(ScopedCloneableDirectionParameters self) -> DirectionParameters""" + return _six_sicd.ScopedCloneableDirectionParameters_clone(self) + + __swig_setmethods__["unitVector"] = _six_sicd.ScopedCloneableDirectionParameters_unitVector_set + __swig_getmethods__["unitVector"] = _six_sicd.ScopedCloneableDirectionParameters_unitVector_get + if _newclass: + unitVector = _swig_property(_six_sicd.ScopedCloneableDirectionParameters_unitVector_get, _six_sicd.ScopedCloneableDirectionParameters_unitVector_set) + __swig_setmethods__["sampleSpacing"] = _six_sicd.ScopedCloneableDirectionParameters_sampleSpacing_set + __swig_getmethods__["sampleSpacing"] = _six_sicd.ScopedCloneableDirectionParameters_sampleSpacing_get + if _newclass: + sampleSpacing = _swig_property(_six_sicd.ScopedCloneableDirectionParameters_sampleSpacing_get, _six_sicd.ScopedCloneableDirectionParameters_sampleSpacing_set) + __swig_setmethods__["impulseResponseWidth"] = _six_sicd.ScopedCloneableDirectionParameters_impulseResponseWidth_set + __swig_getmethods__["impulseResponseWidth"] = _six_sicd.ScopedCloneableDirectionParameters_impulseResponseWidth_get + if _newclass: + impulseResponseWidth = _swig_property(_six_sicd.ScopedCloneableDirectionParameters_impulseResponseWidth_get, _six_sicd.ScopedCloneableDirectionParameters_impulseResponseWidth_set) + __swig_setmethods__["sign"] = _six_sicd.ScopedCloneableDirectionParameters_sign_set + __swig_getmethods__["sign"] = _six_sicd.ScopedCloneableDirectionParameters_sign_get + if _newclass: + sign = _swig_property(_six_sicd.ScopedCloneableDirectionParameters_sign_get, _six_sicd.ScopedCloneableDirectionParameters_sign_set) + __swig_setmethods__["impulseResponseBandwidth"] = _six_sicd.ScopedCloneableDirectionParameters_impulseResponseBandwidth_set + __swig_getmethods__["impulseResponseBandwidth"] = _six_sicd.ScopedCloneableDirectionParameters_impulseResponseBandwidth_get + if _newclass: + impulseResponseBandwidth = _swig_property(_six_sicd.ScopedCloneableDirectionParameters_impulseResponseBandwidth_get, _six_sicd.ScopedCloneableDirectionParameters_impulseResponseBandwidth_set) + __swig_setmethods__["kCenter"] = _six_sicd.ScopedCloneableDirectionParameters_kCenter_set + __swig_getmethods__["kCenter"] = _six_sicd.ScopedCloneableDirectionParameters_kCenter_get + if _newclass: + kCenter = _swig_property(_six_sicd.ScopedCloneableDirectionParameters_kCenter_get, _six_sicd.ScopedCloneableDirectionParameters_kCenter_set) + __swig_setmethods__["deltaK1"] = _six_sicd.ScopedCloneableDirectionParameters_deltaK1_set + __swig_getmethods__["deltaK1"] = _six_sicd.ScopedCloneableDirectionParameters_deltaK1_get + if _newclass: + deltaK1 = _swig_property(_six_sicd.ScopedCloneableDirectionParameters_deltaK1_get, _six_sicd.ScopedCloneableDirectionParameters_deltaK1_set) + __swig_setmethods__["deltaK2"] = _six_sicd.ScopedCloneableDirectionParameters_deltaK2_set + __swig_getmethods__["deltaK2"] = _six_sicd.ScopedCloneableDirectionParameters_deltaK2_get + if _newclass: + deltaK2 = _swig_property(_six_sicd.ScopedCloneableDirectionParameters_deltaK2_get, _six_sicd.ScopedCloneableDirectionParameters_deltaK2_set) + __swig_setmethods__["deltaKCOAPoly"] = _six_sicd.ScopedCloneableDirectionParameters_deltaKCOAPoly_set + __swig_getmethods__["deltaKCOAPoly"] = _six_sicd.ScopedCloneableDirectionParameters_deltaKCOAPoly_get + if _newclass: + deltaKCOAPoly = _swig_property(_six_sicd.ScopedCloneableDirectionParameters_deltaKCOAPoly_get, _six_sicd.ScopedCloneableDirectionParameters_deltaKCOAPoly_set) + __swig_setmethods__["weightType"] = _six_sicd.ScopedCloneableDirectionParameters_weightType_set + __swig_getmethods__["weightType"] = _six_sicd.ScopedCloneableDirectionParameters_weightType_get + if _newclass: + weightType = _swig_property(_six_sicd.ScopedCloneableDirectionParameters_weightType_get, _six_sicd.ScopedCloneableDirectionParameters_weightType_set) + __swig_setmethods__["weights"] = _six_sicd.ScopedCloneableDirectionParameters_weights_set + __swig_getmethods__["weights"] = _six_sicd.ScopedCloneableDirectionParameters_weights_get + if _newclass: + weights = _swig_property(_six_sicd.ScopedCloneableDirectionParameters_weights_get, _six_sicd.ScopedCloneableDirectionParameters_weights_set) +ScopedCloneableDirectionParameters_swigregister = _six_sicd.ScopedCloneableDirectionParameters_swigregister +ScopedCloneableDirectionParameters_swigregister(ScopedCloneableDirectionParameters) + class ScopedCloneableAreaDirectionParameters(_object): - """Proxy of C++ mem::ScopedCopyablePtr<(six::sicd::AreaDirectionParameters)> class""" + """Proxy of C++ mem::ScopedCloneablePtr<(six::sicd::AreaDirectionParameters)> class""" __swig_setmethods__ = {} __setattr__ = lambda self, name, value: _swig_setattr(self, ScopedCloneableAreaDirectionParameters, name, value) __swig_getmethods__ = {} @@ -4771,9 +4867,9 @@ class ScopedCloneableAreaDirectionParameters(_object): def __init__(self, *args): """ - __init__(mem::ScopedCopyablePtr<(six::sicd::AreaDirectionParameters)> self, AreaDirectionParameters ptr=None) -> ScopedCloneableAreaDirectionParameters - __init__(mem::ScopedCopyablePtr<(six::sicd::AreaDirectionParameters)> self) -> ScopedCloneableAreaDirectionParameters - __init__(mem::ScopedCopyablePtr<(six::sicd::AreaDirectionParameters)> self, ScopedCloneableAreaDirectionParameters rhs) -> ScopedCloneableAreaDirectionParameters + __init__(mem::ScopedCloneablePtr<(six::sicd::AreaDirectionParameters)> self, AreaDirectionParameters ptr=None) -> ScopedCloneableAreaDirectionParameters + __init__(mem::ScopedCloneablePtr<(six::sicd::AreaDirectionParameters)> self) -> ScopedCloneableAreaDirectionParameters + __init__(mem::ScopedCloneablePtr<(six::sicd::AreaDirectionParameters)> self, ScopedCloneableAreaDirectionParameters rhs) -> ScopedCloneableAreaDirectionParameters """ this = _six_sicd.new_ScopedCloneableAreaDirectionParameters(*args) try: diff --git a/modules/python/six.sicd/source/generated/six_sicd_wrap.cxx b/modules/python/six.sicd/source/generated/six_sicd_wrap.cxx index 21bb54a5a..406005517 100644 --- a/modules/python/six.sicd/source/generated/six_sicd_wrap.cxx +++ b/modules/python/six.sicd/source/generated/six_sicd_wrap.cxx @@ -2992,173 +2992,172 @@ SWIG_Python_NonDynamicSetAttr(PyObject *obj, PyObject *name, PyObject *value) { #define SWIGTYPE_p_mem__ScopedCopyablePtrT_six__TropoError_t swig_types[52] #define SWIGTYPE_p_mem__ScopedCopyablePtrT_six__sicd__AntennaParameters_t swig_types[53] #define SWIGTYPE_p_mem__ScopedCopyablePtrT_six__sicd__Antenna_t swig_types[54] -#define SWIGTYPE_p_mem__ScopedCopyablePtrT_six__sicd__AreaDirectionParameters_t swig_types[55] -#define SWIGTYPE_p_mem__ScopedCopyablePtrT_six__sicd__Distortion_t swig_types[56] -#define SWIGTYPE_p_mem__ScopedCopyablePtrT_six__sicd__ElectricalBoresight_t swig_types[57] -#define SWIGTYPE_p_mem__ScopedCopyablePtrT_six__sicd__GainAndPhasePolys_t swig_types[58] -#define SWIGTYPE_p_mem__ScopedCopyablePtrT_six__sicd__HalfPowerBeamwidths_t swig_types[59] -#define SWIGTYPE_p_mem__ScopedCopyablePtrT_six__sicd__INCA_t swig_types[60] -#define SWIGTYPE_p_mem__ScopedCopyablePtrT_six__sicd__ImageFormation_t swig_types[61] -#define SWIGTYPE_p_mem__ScopedCopyablePtrT_six__sicd__MatchInformation_t swig_types[62] -#define SWIGTYPE_p_mem__ScopedCopyablePtrT_six__sicd__MatchType_t swig_types[63] -#define SWIGTYPE_p_mem__ScopedCopyablePtrT_six__sicd__PolarizationCalibration_t swig_types[64] -#define SWIGTYPE_p_mem__ScopedCopyablePtrT_six__sicd__RMAT_t swig_types[65] -#define SWIGTYPE_p_mem__ScopedCopyablePtrT_six__sicd__RMA_t swig_types[66] -#define SWIGTYPE_p_mem__ScopedCopyablePtrT_six__sicd__RMCR_t swig_types[67] -#define SWIGTYPE_p_mem__ScopedCopyablePtrT_six__sicd__RcvChannelProcessed_t swig_types[68] -#define SWIGTYPE_p_mem__ScopedCopyablePtrT_six__sicd__RgAzComp_t swig_types[69] -#define SWIGTYPE_p_mem__ScopedCopyablePtrT_six__sicd__SCPCOA_t swig_types[70] -#define SWIGTYPE_p_mem__ScopedCopyablePtrT_six__sicd__WeightType_t swig_types[71] -#define SWIGTYPE_p_nitf__DateTime swig_types[72] -#define SWIGTYPE_p_off_t swig_types[73] -#define SWIGTYPE_p_p_PyObject swig_types[74] -#define SWIGTYPE_p_pid_t swig_types[75] -#define SWIGTYPE_p_reference swig_types[76] -#define SWIGTYPE_p_scene__AngleMagnitude swig_types[77] -#define SWIGTYPE_p_scene__FrameType swig_types[78] -#define SWIGTYPE_p_scene__GeodeticProjectionModel swig_types[79] -#define SWIGTYPE_p_scene__LatLon swig_types[80] -#define SWIGTYPE_p_scene__LatLonAlt swig_types[81] -#define SWIGTYPE_p_scene__PlaneProjectionModel swig_types[82] -#define SWIGTYPE_p_scene__ProjectionModel swig_types[83] -#define SWIGTYPE_p_scene__ProjectionModelWithImageVectors swig_types[84] -#define SWIGTYPE_p_scene__RangeAzimProjectionModel swig_types[85] -#define SWIGTYPE_p_scene__RangeZeroProjectionModel swig_types[86] -#define SWIGTYPE_p_scene__SceneGeometry swig_types[87] -#define SWIGTYPE_p_six__AmplitudeTable swig_types[88] -#define SWIGTYPE_p_six__AppliedType swig_types[89] -#define SWIGTYPE_p_six__AutofocusType swig_types[90] -#define SWIGTYPE_p_six__BooleanType swig_types[91] -#define SWIGTYPE_p_six__Classification swig_types[92] -#define SWIGTYPE_p_six__CollectType swig_types[93] -#define SWIGTYPE_p_six__ComplexImageGridType swig_types[94] -#define SWIGTYPE_p_six__ComplexImagePlaneType swig_types[95] -#define SWIGTYPE_p_six__Components swig_types[96] -#define SWIGTYPE_p_six__CompositeSCP swig_types[97] -#define SWIGTYPE_p_six__CornersT_scene__LatLonAlt_t swig_types[98] -#define SWIGTYPE_p_six__CornersT_scene__LatLon_t swig_types[99] -#define SWIGTYPE_p_six__Data swig_types[100] -#define SWIGTYPE_p_six__DataType swig_types[101] -#define SWIGTYPE_p_six__DecorrType swig_types[102] -#define SWIGTYPE_p_six__DemodType swig_types[103] -#define SWIGTYPE_p_six__DualPolarizationType swig_types[104] -#define SWIGTYPE_p_six__EarthModelType swig_types[105] -#define SWIGTYPE_p_six__ErrorStatistics swig_types[106] -#define SWIGTYPE_p_six__FFTSign swig_types[107] -#define SWIGTYPE_p_six__ImageBeamCompensationType swig_types[108] -#define SWIGTYPE_p_six__ImageFormationType swig_types[109] -#define SWIGTYPE_p_six__IonoError swig_types[110] -#define SWIGTYPE_p_six__LUT swig_types[111] -#define SWIGTYPE_p_six__NoiseLevel swig_types[112] -#define SWIGTYPE_p_six__OrientationType swig_types[113] -#define SWIGTYPE_p_six__ParameterCollection swig_types[114] -#define SWIGTYPE_p_six__PixelType swig_types[115] -#define SWIGTYPE_p_six__PolarizationSequenceType swig_types[116] -#define SWIGTYPE_p_six__PolarizationType swig_types[117] -#define SWIGTYPE_p_six__PosVelError swig_types[118] -#define SWIGTYPE_p_six__RMAlgoType swig_types[119] -#define SWIGTYPE_p_six__RadarModeType swig_types[120] -#define SWIGTYPE_p_six__RadarSensor swig_types[121] -#define SWIGTYPE_p_six__Radiometric swig_types[122] -#define SWIGTYPE_p_six__ReferencePoint swig_types[123] -#define SWIGTYPE_p_six__SCP swig_types[124] -#define SWIGTYPE_p_six__SideOfTrackType swig_types[125] -#define SWIGTYPE_p_six__SlowTimeBeamCompensationType swig_types[126] -#define SWIGTYPE_p_six__TropoError swig_types[127] -#define SWIGTYPE_p_six__XMLControl swig_types[128] -#define SWIGTYPE_p_six__sicd__Antenna swig_types[129] -#define SWIGTYPE_p_six__sicd__AntennaParameters swig_types[130] -#define SWIGTYPE_p_six__sicd__Area swig_types[131] -#define SWIGTYPE_p_six__sicd__AreaDirectionParameters swig_types[132] -#define SWIGTYPE_p_six__sicd__AreaPlane swig_types[133] -#define SWIGTYPE_p_six__sicd__ChannelParameters swig_types[134] -#define SWIGTYPE_p_six__sicd__CollectionInformation swig_types[135] -#define SWIGTYPE_p_six__sicd__ComplexClassification swig_types[136] -#define SWIGTYPE_p_six__sicd__ComplexData swig_types[137] -#define SWIGTYPE_p_six__sicd__ComplexXMLControl swig_types[138] -#define SWIGTYPE_p_six__sicd__DirectionParameters swig_types[139] -#define SWIGTYPE_p_six__sicd__Distortion swig_types[140] -#define SWIGTYPE_p_six__sicd__ElectricalBoresight swig_types[141] -#define SWIGTYPE_p_six__sicd__GainAndPhasePolys swig_types[142] -#define SWIGTYPE_p_six__sicd__GeoData swig_types[143] -#define SWIGTYPE_p_six__sicd__GeoInfo swig_types[144] -#define SWIGTYPE_p_six__sicd__Grid swig_types[145] -#define SWIGTYPE_p_six__sicd__HalfPowerBeamwidths swig_types[146] -#define SWIGTYPE_p_six__sicd__INCA swig_types[147] -#define SWIGTYPE_p_six__sicd__ImageCreation swig_types[148] -#define SWIGTYPE_p_six__sicd__ImageData swig_types[149] -#define SWIGTYPE_p_six__sicd__ImageFormation swig_types[150] -#define SWIGTYPE_p_six__sicd__InterPulsePeriod swig_types[151] -#define SWIGTYPE_p_six__sicd__MatchCollect swig_types[152] -#define SWIGTYPE_p_six__sicd__MatchInformation swig_types[153] -#define SWIGTYPE_p_six__sicd__MatchType swig_types[154] -#define SWIGTYPE_p_six__sicd__PFA swig_types[155] -#define SWIGTYPE_p_six__sicd__PolarizationCalibration swig_types[156] -#define SWIGTYPE_p_six__sicd__Position swig_types[157] -#define SWIGTYPE_p_six__sicd__Processing swig_types[158] -#define SWIGTYPE_p_six__sicd__RMA swig_types[159] -#define SWIGTYPE_p_six__sicd__RMAT swig_types[160] -#define SWIGTYPE_p_six__sicd__RMCR swig_types[161] -#define SWIGTYPE_p_six__sicd__RadarCollection swig_types[162] -#define SWIGTYPE_p_six__sicd__RcvAPC swig_types[163] -#define SWIGTYPE_p_six__sicd__RcvChannelProcessed swig_types[164] -#define SWIGTYPE_p_six__sicd__RgAzComp swig_types[165] -#define SWIGTYPE_p_six__sicd__SCPCOA swig_types[166] -#define SWIGTYPE_p_six__sicd__Segment swig_types[167] -#define SWIGTYPE_p_six__sicd__SlowTimeDeskew swig_types[168] -#define SWIGTYPE_p_six__sicd__Timeline swig_types[169] -#define SWIGTYPE_p_six__sicd__TimelineSet swig_types[170] -#define SWIGTYPE_p_six__sicd__TxStep swig_types[171] -#define SWIGTYPE_p_six__sicd__Utilities swig_types[172] -#define SWIGTYPE_p_six__sicd__WaveformParameters swig_types[173] -#define SWIGTYPE_p_six__sicd__WeightType swig_types[174] -#define SWIGTYPE_p_size_t swig_types[175] -#define SWIGTYPE_p_size_type swig_types[176] -#define SWIGTYPE_p_ssize_t swig_types[177] -#define SWIGTYPE_p_std__allocatorT_PolyXYZ_t swig_types[178] -#define SWIGTYPE_p_std__allocatorT_int_t swig_types[179] -#define SWIGTYPE_p_std__allocatorT_mem__ScopedCloneablePtrT_six__sicd__ChannelParameters_t_t swig_types[180] -#define SWIGTYPE_p_std__allocatorT_mem__ScopedCloneablePtrT_six__sicd__GeoInfo_t_t swig_types[181] -#define SWIGTYPE_p_std__allocatorT_mem__ScopedCloneablePtrT_six__sicd__Segment_t_t swig_types[182] -#define SWIGTYPE_p_std__allocatorT_mem__ScopedCloneablePtrT_six__sicd__TxStep_t_t swig_types[183] -#define SWIGTYPE_p_std__allocatorT_mem__ScopedCloneablePtrT_six__sicd__WaveformParameters_t_t swig_types[184] -#define SWIGTYPE_p_std__allocatorT_mem__ScopedCopyablePtrT_six__sicd__MatchType_t_t swig_types[185] -#define SWIGTYPE_p_std__allocatorT_scene__LatLon_t swig_types[186] -#define SWIGTYPE_p_std__allocatorT_six__sicd__MatchCollect_t swig_types[187] -#define SWIGTYPE_p_std__allocatorT_six__sicd__Processing_t swig_types[188] -#define SWIGTYPE_p_std__allocatorT_six__sicd__TimelineSet_p_t swig_types[189] -#define SWIGTYPE_p_std__complexT_float_t swig_types[190] -#define SWIGTYPE_p_std__invalid_argument swig_types[191] -#define SWIGTYPE_p_std__ostream swig_types[192] -#define SWIGTYPE_p_std__vectorT_PolyXYZ_std__allocatorT_PolyXYZ_t_t swig_types[193] -#define SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t swig_types[194] -#define SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t swig_types[195] -#define SWIGTYPE_p_std__vectorT_math__poly__OneDT_Vector3_t_std__allocatorT_math__poly__OneDT_Vector3_t_t_t swig_types[196] -#define SWIGTYPE_p_std__vectorT_mem__ScopedCloneablePtrT_six__sicd__ChannelParameters_t_std__allocatorT_mem__ScopedCloneablePtrT_six__sicd__ChannelParameters_t_t_t swig_types[197] -#define SWIGTYPE_p_std__vectorT_mem__ScopedCloneablePtrT_six__sicd__GeoInfo_t_std__allocatorT_mem__ScopedCloneablePtrT_six__sicd__GeoInfo_t_t_t swig_types[198] -#define SWIGTYPE_p_std__vectorT_mem__ScopedCloneablePtrT_six__sicd__Segment_t_std__allocatorT_mem__ScopedCloneablePtrT_six__sicd__Segment_t_t_t swig_types[199] -#define SWIGTYPE_p_std__vectorT_mem__ScopedCloneablePtrT_six__sicd__TxStep_t_std__allocatorT_mem__ScopedCloneablePtrT_six__sicd__TxStep_t_t_t swig_types[200] -#define SWIGTYPE_p_std__vectorT_mem__ScopedCloneablePtrT_six__sicd__WaveformParameters_t_std__allocatorT_mem__ScopedCloneablePtrT_six__sicd__WaveformParameters_t_t_t swig_types[201] -#define SWIGTYPE_p_std__vectorT_mem__ScopedCopyablePtrT_six__sicd__MatchType_t_std__allocatorT_mem__ScopedCopyablePtrT_six__sicd__MatchType_t_t_t swig_types[202] -#define SWIGTYPE_p_std__vectorT_scene__LatLon_std__allocatorT_scene__LatLon_t_t swig_types[203] -#define SWIGTYPE_p_std__vectorT_six__sicd__MatchCollect_std__allocatorT_six__sicd__MatchCollect_t_t swig_types[204] -#define SWIGTYPE_p_std__vectorT_six__sicd__Processing_std__allocatorT_six__sicd__Processing_t_t swig_types[205] -#define SWIGTYPE_p_std__vectorT_six__sicd__TimelineSet_p_std__allocatorT_six__sicd__TimelineSet_p_t_t swig_types[206] -#define SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t swig_types[207] -#define SWIGTYPE_p_std__vectorT_types__RowColT_sys__SSize_T_t_std__allocatorT_types__RowColT_sys__SSize_T_t_t_t swig_types[208] -#define SWIGTYPE_p_swig__SwigPyIterator swig_types[209] -#define SWIGTYPE_p_types__RowColT_double_t swig_types[210] -#define SWIGTYPE_p_types__RowColT_math__poly__TwoDT_double_t_t swig_types[211] -#define SWIGTYPE_p_types__RowColT_scene__LatLon_t swig_types[212] -#define SWIGTYPE_p_types__RowColT_ssize_t_t swig_types[213] -#define SWIGTYPE_p_uint16_t swig_types[214] -#define SWIGTYPE_p_uint32_t swig_types[215] -#define SWIGTYPE_p_uint64_t swig_types[216] -#define SWIGTYPE_p_uint8_t swig_types[217] -#define SWIGTYPE_p_unsigned_char swig_types[218] -#define SWIGTYPE_p_value_type swig_types[219] -static swig_type_info *swig_types[221]; -static swig_module_info swig_module = {swig_types, 220, 0, 0, 0, 0}; +#define SWIGTYPE_p_mem__ScopedCopyablePtrT_six__sicd__Distortion_t swig_types[55] +#define SWIGTYPE_p_mem__ScopedCopyablePtrT_six__sicd__ElectricalBoresight_t swig_types[56] +#define SWIGTYPE_p_mem__ScopedCopyablePtrT_six__sicd__GainAndPhasePolys_t swig_types[57] +#define SWIGTYPE_p_mem__ScopedCopyablePtrT_six__sicd__HalfPowerBeamwidths_t swig_types[58] +#define SWIGTYPE_p_mem__ScopedCopyablePtrT_six__sicd__INCA_t swig_types[59] +#define SWIGTYPE_p_mem__ScopedCopyablePtrT_six__sicd__ImageFormation_t swig_types[60] +#define SWIGTYPE_p_mem__ScopedCopyablePtrT_six__sicd__MatchInformation_t swig_types[61] +#define SWIGTYPE_p_mem__ScopedCopyablePtrT_six__sicd__MatchType_t swig_types[62] +#define SWIGTYPE_p_mem__ScopedCopyablePtrT_six__sicd__PolarizationCalibration_t swig_types[63] +#define SWIGTYPE_p_mem__ScopedCopyablePtrT_six__sicd__RMAT_t swig_types[64] +#define SWIGTYPE_p_mem__ScopedCopyablePtrT_six__sicd__RMA_t swig_types[65] +#define SWIGTYPE_p_mem__ScopedCopyablePtrT_six__sicd__RMCR_t swig_types[66] +#define SWIGTYPE_p_mem__ScopedCopyablePtrT_six__sicd__RcvChannelProcessed_t swig_types[67] +#define SWIGTYPE_p_mem__ScopedCopyablePtrT_six__sicd__RgAzComp_t swig_types[68] +#define SWIGTYPE_p_mem__ScopedCopyablePtrT_six__sicd__SCPCOA_t swig_types[69] +#define SWIGTYPE_p_mem__ScopedCopyablePtrT_six__sicd__WeightType_t swig_types[70] +#define SWIGTYPE_p_nitf__DateTime swig_types[71] +#define SWIGTYPE_p_off_t swig_types[72] +#define SWIGTYPE_p_p_PyObject swig_types[73] +#define SWIGTYPE_p_pid_t swig_types[74] +#define SWIGTYPE_p_reference swig_types[75] +#define SWIGTYPE_p_scene__AngleMagnitude swig_types[76] +#define SWIGTYPE_p_scene__FrameType swig_types[77] +#define SWIGTYPE_p_scene__GeodeticProjectionModel swig_types[78] +#define SWIGTYPE_p_scene__LatLon swig_types[79] +#define SWIGTYPE_p_scene__LatLonAlt swig_types[80] +#define SWIGTYPE_p_scene__PlaneProjectionModel swig_types[81] +#define SWIGTYPE_p_scene__ProjectionModel swig_types[82] +#define SWIGTYPE_p_scene__ProjectionModelWithImageVectors swig_types[83] +#define SWIGTYPE_p_scene__RangeAzimProjectionModel swig_types[84] +#define SWIGTYPE_p_scene__RangeZeroProjectionModel swig_types[85] +#define SWIGTYPE_p_scene__SceneGeometry swig_types[86] +#define SWIGTYPE_p_six__AmplitudeTable swig_types[87] +#define SWIGTYPE_p_six__AppliedType swig_types[88] +#define SWIGTYPE_p_six__AutofocusType swig_types[89] +#define SWIGTYPE_p_six__BooleanType swig_types[90] +#define SWIGTYPE_p_six__Classification swig_types[91] +#define SWIGTYPE_p_six__CollectType swig_types[92] +#define SWIGTYPE_p_six__ComplexImageGridType swig_types[93] +#define SWIGTYPE_p_six__ComplexImagePlaneType swig_types[94] +#define SWIGTYPE_p_six__Components swig_types[95] +#define SWIGTYPE_p_six__CompositeSCP swig_types[96] +#define SWIGTYPE_p_six__CornersT_scene__LatLonAlt_t swig_types[97] +#define SWIGTYPE_p_six__CornersT_scene__LatLon_t swig_types[98] +#define SWIGTYPE_p_six__Data swig_types[99] +#define SWIGTYPE_p_six__DataType swig_types[100] +#define SWIGTYPE_p_six__DecorrType swig_types[101] +#define SWIGTYPE_p_six__DemodType swig_types[102] +#define SWIGTYPE_p_six__DualPolarizationType swig_types[103] +#define SWIGTYPE_p_six__EarthModelType swig_types[104] +#define SWIGTYPE_p_six__ErrorStatistics swig_types[105] +#define SWIGTYPE_p_six__FFTSign swig_types[106] +#define SWIGTYPE_p_six__ImageBeamCompensationType swig_types[107] +#define SWIGTYPE_p_six__ImageFormationType swig_types[108] +#define SWIGTYPE_p_six__IonoError swig_types[109] +#define SWIGTYPE_p_six__LUT swig_types[110] +#define SWIGTYPE_p_six__NoiseLevel swig_types[111] +#define SWIGTYPE_p_six__OrientationType swig_types[112] +#define SWIGTYPE_p_six__ParameterCollection swig_types[113] +#define SWIGTYPE_p_six__PixelType swig_types[114] +#define SWIGTYPE_p_six__PolarizationSequenceType swig_types[115] +#define SWIGTYPE_p_six__PolarizationType swig_types[116] +#define SWIGTYPE_p_six__PosVelError swig_types[117] +#define SWIGTYPE_p_six__RMAlgoType swig_types[118] +#define SWIGTYPE_p_six__RadarModeType swig_types[119] +#define SWIGTYPE_p_six__RadarSensor swig_types[120] +#define SWIGTYPE_p_six__Radiometric swig_types[121] +#define SWIGTYPE_p_six__ReferencePoint swig_types[122] +#define SWIGTYPE_p_six__SCP swig_types[123] +#define SWIGTYPE_p_six__SideOfTrackType swig_types[124] +#define SWIGTYPE_p_six__SlowTimeBeamCompensationType swig_types[125] +#define SWIGTYPE_p_six__TropoError swig_types[126] +#define SWIGTYPE_p_six__XMLControl swig_types[127] +#define SWIGTYPE_p_six__sicd__Antenna swig_types[128] +#define SWIGTYPE_p_six__sicd__AntennaParameters swig_types[129] +#define SWIGTYPE_p_six__sicd__Area swig_types[130] +#define SWIGTYPE_p_six__sicd__AreaDirectionParameters swig_types[131] +#define SWIGTYPE_p_six__sicd__AreaPlane swig_types[132] +#define SWIGTYPE_p_six__sicd__ChannelParameters swig_types[133] +#define SWIGTYPE_p_six__sicd__CollectionInformation swig_types[134] +#define SWIGTYPE_p_six__sicd__ComplexClassification swig_types[135] +#define SWIGTYPE_p_six__sicd__ComplexData swig_types[136] +#define SWIGTYPE_p_six__sicd__ComplexXMLControl swig_types[137] +#define SWIGTYPE_p_six__sicd__DirectionParameters swig_types[138] +#define SWIGTYPE_p_six__sicd__Distortion swig_types[139] +#define SWIGTYPE_p_six__sicd__ElectricalBoresight swig_types[140] +#define SWIGTYPE_p_six__sicd__GainAndPhasePolys swig_types[141] +#define SWIGTYPE_p_six__sicd__GeoData swig_types[142] +#define SWIGTYPE_p_six__sicd__GeoInfo swig_types[143] +#define SWIGTYPE_p_six__sicd__Grid swig_types[144] +#define SWIGTYPE_p_six__sicd__HalfPowerBeamwidths swig_types[145] +#define SWIGTYPE_p_six__sicd__INCA swig_types[146] +#define SWIGTYPE_p_six__sicd__ImageCreation swig_types[147] +#define SWIGTYPE_p_six__sicd__ImageData swig_types[148] +#define SWIGTYPE_p_six__sicd__ImageFormation swig_types[149] +#define SWIGTYPE_p_six__sicd__InterPulsePeriod swig_types[150] +#define SWIGTYPE_p_six__sicd__MatchCollect swig_types[151] +#define SWIGTYPE_p_six__sicd__MatchInformation swig_types[152] +#define SWIGTYPE_p_six__sicd__MatchType swig_types[153] +#define SWIGTYPE_p_six__sicd__PFA swig_types[154] +#define SWIGTYPE_p_six__sicd__PolarizationCalibration swig_types[155] +#define SWIGTYPE_p_six__sicd__Position swig_types[156] +#define SWIGTYPE_p_six__sicd__Processing swig_types[157] +#define SWIGTYPE_p_six__sicd__RMA swig_types[158] +#define SWIGTYPE_p_six__sicd__RMAT swig_types[159] +#define SWIGTYPE_p_six__sicd__RMCR swig_types[160] +#define SWIGTYPE_p_six__sicd__RadarCollection swig_types[161] +#define SWIGTYPE_p_six__sicd__RcvAPC swig_types[162] +#define SWIGTYPE_p_six__sicd__RcvChannelProcessed swig_types[163] +#define SWIGTYPE_p_six__sicd__RgAzComp swig_types[164] +#define SWIGTYPE_p_six__sicd__SCPCOA swig_types[165] +#define SWIGTYPE_p_six__sicd__Segment swig_types[166] +#define SWIGTYPE_p_six__sicd__SlowTimeDeskew swig_types[167] +#define SWIGTYPE_p_six__sicd__Timeline swig_types[168] +#define SWIGTYPE_p_six__sicd__TimelineSet swig_types[169] +#define SWIGTYPE_p_six__sicd__TxStep swig_types[170] +#define SWIGTYPE_p_six__sicd__Utilities swig_types[171] +#define SWIGTYPE_p_six__sicd__WaveformParameters swig_types[172] +#define SWIGTYPE_p_six__sicd__WeightType swig_types[173] +#define SWIGTYPE_p_size_t swig_types[174] +#define SWIGTYPE_p_size_type swig_types[175] +#define SWIGTYPE_p_ssize_t swig_types[176] +#define SWIGTYPE_p_std__allocatorT_PolyXYZ_t swig_types[177] +#define SWIGTYPE_p_std__allocatorT_int_t swig_types[178] +#define SWIGTYPE_p_std__allocatorT_mem__ScopedCloneablePtrT_six__sicd__ChannelParameters_t_t swig_types[179] +#define SWIGTYPE_p_std__allocatorT_mem__ScopedCloneablePtrT_six__sicd__GeoInfo_t_t swig_types[180] +#define SWIGTYPE_p_std__allocatorT_mem__ScopedCloneablePtrT_six__sicd__Segment_t_t swig_types[181] +#define SWIGTYPE_p_std__allocatorT_mem__ScopedCloneablePtrT_six__sicd__TxStep_t_t swig_types[182] +#define SWIGTYPE_p_std__allocatorT_mem__ScopedCloneablePtrT_six__sicd__WaveformParameters_t_t swig_types[183] +#define SWIGTYPE_p_std__allocatorT_mem__ScopedCopyablePtrT_six__sicd__MatchType_t_t swig_types[184] +#define SWIGTYPE_p_std__allocatorT_scene__LatLon_t swig_types[185] +#define SWIGTYPE_p_std__allocatorT_six__sicd__MatchCollect_t swig_types[186] +#define SWIGTYPE_p_std__allocatorT_six__sicd__Processing_t swig_types[187] +#define SWIGTYPE_p_std__allocatorT_six__sicd__TimelineSet_p_t swig_types[188] +#define SWIGTYPE_p_std__complexT_float_t swig_types[189] +#define SWIGTYPE_p_std__invalid_argument swig_types[190] +#define SWIGTYPE_p_std__ostream swig_types[191] +#define SWIGTYPE_p_std__vectorT_PolyXYZ_std__allocatorT_PolyXYZ_t_t swig_types[192] +#define SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t swig_types[193] +#define SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t swig_types[194] +#define SWIGTYPE_p_std__vectorT_math__poly__OneDT_Vector3_t_std__allocatorT_math__poly__OneDT_Vector3_t_t_t swig_types[195] +#define SWIGTYPE_p_std__vectorT_mem__ScopedCloneablePtrT_six__sicd__ChannelParameters_t_std__allocatorT_mem__ScopedCloneablePtrT_six__sicd__ChannelParameters_t_t_t swig_types[196] +#define SWIGTYPE_p_std__vectorT_mem__ScopedCloneablePtrT_six__sicd__GeoInfo_t_std__allocatorT_mem__ScopedCloneablePtrT_six__sicd__GeoInfo_t_t_t swig_types[197] +#define SWIGTYPE_p_std__vectorT_mem__ScopedCloneablePtrT_six__sicd__Segment_t_std__allocatorT_mem__ScopedCloneablePtrT_six__sicd__Segment_t_t_t swig_types[198] +#define SWIGTYPE_p_std__vectorT_mem__ScopedCloneablePtrT_six__sicd__TxStep_t_std__allocatorT_mem__ScopedCloneablePtrT_six__sicd__TxStep_t_t_t swig_types[199] +#define SWIGTYPE_p_std__vectorT_mem__ScopedCloneablePtrT_six__sicd__WaveformParameters_t_std__allocatorT_mem__ScopedCloneablePtrT_six__sicd__WaveformParameters_t_t_t swig_types[200] +#define SWIGTYPE_p_std__vectorT_mem__ScopedCopyablePtrT_six__sicd__MatchType_t_std__allocatorT_mem__ScopedCopyablePtrT_six__sicd__MatchType_t_t_t swig_types[201] +#define SWIGTYPE_p_std__vectorT_scene__LatLon_std__allocatorT_scene__LatLon_t_t swig_types[202] +#define SWIGTYPE_p_std__vectorT_six__sicd__MatchCollect_std__allocatorT_six__sicd__MatchCollect_t_t swig_types[203] +#define SWIGTYPE_p_std__vectorT_six__sicd__Processing_std__allocatorT_six__sicd__Processing_t_t swig_types[204] +#define SWIGTYPE_p_std__vectorT_six__sicd__TimelineSet_p_std__allocatorT_six__sicd__TimelineSet_p_t_t swig_types[205] +#define SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t swig_types[206] +#define SWIGTYPE_p_std__vectorT_types__RowColT_sys__SSize_T_t_std__allocatorT_types__RowColT_sys__SSize_T_t_t_t swig_types[207] +#define SWIGTYPE_p_swig__SwigPyIterator swig_types[208] +#define SWIGTYPE_p_types__RowColT_double_t swig_types[209] +#define SWIGTYPE_p_types__RowColT_math__poly__TwoDT_double_t_t swig_types[210] +#define SWIGTYPE_p_types__RowColT_scene__LatLon_t swig_types[211] +#define SWIGTYPE_p_types__RowColT_ssize_t_t swig_types[212] +#define SWIGTYPE_p_uint16_t swig_types[213] +#define SWIGTYPE_p_uint32_t swig_types[214] +#define SWIGTYPE_p_uint64_t swig_types[215] +#define SWIGTYPE_p_uint8_t swig_types[216] +#define SWIGTYPE_p_unsigned_char swig_types[217] +#define SWIGTYPE_p_value_type swig_types[218] +static swig_type_info *swig_types[220]; +static swig_module_info swig_module = {swig_types, 219, 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) @@ -81276,24 +81275,24 @@ SWIGINTERN PyObject *VectorPolyXYZ_swigregister(PyObject *SWIGUNUSEDPARM(self), return SWIG_Py_Void(); } -SWIGINTERN PyObject *_wrap_new_ScopedCloneableAreaDirectionParameters__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_ScopedCloneableDirectionParameters__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - six::sicd::AreaDirectionParameters *arg1 = (six::sicd::AreaDirectionParameters *) 0 ; + six::sicd::DirectionParameters *arg1 = (six::sicd::DirectionParameters *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; - mem::ScopedCopyablePtr< six::sicd::AreaDirectionParameters > *result = 0 ; + mem::ScopedCloneablePtr< six::sicd::DirectionParameters > *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:new_ScopedCloneableAreaDirectionParameters",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_six__sicd__AreaDirectionParameters, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"O:new_ScopedCloneableDirectionParameters",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_six__sicd__DirectionParameters, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ScopedCloneableAreaDirectionParameters" "', argument " "1"" of type '" "six::sicd::AreaDirectionParameters *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ScopedCloneableDirectionParameters" "', argument " "1"" of type '" "six::sicd::DirectionParameters *""'"); } - arg1 = reinterpret_cast< six::sicd::AreaDirectionParameters * >(argp1); + arg1 = reinterpret_cast< six::sicd::DirectionParameters * >(argp1); { try { - result = (mem::ScopedCopyablePtr< six::sicd::AreaDirectionParameters > *)new mem::ScopedCopyablePtr< six::sicd::AreaDirectionParameters >(arg1); + result = (mem::ScopedCloneablePtr< six::sicd::DirectionParameters > *)new mem::ScopedCloneablePtr< six::sicd::DirectionParameters >(arg1); } catch (const std::exception& e) { @@ -81321,22 +81320,22 @@ SWIGINTERN PyObject *_wrap_new_ScopedCloneableAreaDirectionParameters__SWIG_0(Py SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mem__ScopedCopyablePtrT_six__sicd__AreaDirectionParameters_t, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__DirectionParameters_t, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_ScopedCloneableAreaDirectionParameters__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_ScopedCloneableDirectionParameters__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mem::ScopedCopyablePtr< six::sicd::AreaDirectionParameters > *result = 0 ; + mem::ScopedCloneablePtr< six::sicd::DirectionParameters > *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)":new_ScopedCloneableAreaDirectionParameters")) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)":new_ScopedCloneableDirectionParameters")) SWIG_fail; { try { - result = (mem::ScopedCopyablePtr< six::sicd::AreaDirectionParameters > *)new mem::ScopedCopyablePtr< six::sicd::AreaDirectionParameters >(); + result = (mem::ScopedCloneablePtr< six::sicd::DirectionParameters > *)new mem::ScopedCloneablePtr< six::sicd::DirectionParameters >(); } catch (const std::exception& e) { @@ -81364,34 +81363,34 @@ SWIGINTERN PyObject *_wrap_new_ScopedCloneableAreaDirectionParameters__SWIG_1(Py SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mem__ScopedCopyablePtrT_six__sicd__AreaDirectionParameters_t, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__DirectionParameters_t, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_ScopedCloneableAreaDirectionParameters__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_ScopedCloneableDirectionParameters__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mem::ScopedCopyablePtr< six::sicd::AreaDirectionParameters > *arg1 = 0 ; + mem::ScopedCloneablePtr< six::sicd::DirectionParameters > *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; - mem::ScopedCopyablePtr< six::sicd::AreaDirectionParameters > *result = 0 ; + mem::ScopedCloneablePtr< six::sicd::DirectionParameters > *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:new_ScopedCloneableAreaDirectionParameters",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mem__ScopedCopyablePtrT_six__sicd__AreaDirectionParameters_t, 0 | 0); + if (!PyArg_ParseTuple(args,(char *)"O:new_ScopedCloneableDirectionParameters",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__DirectionParameters_t, 0 | 0); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ScopedCloneableAreaDirectionParameters" "', argument " "1"" of type '" "mem::ScopedCopyablePtr< six::sicd::AreaDirectionParameters > const &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ScopedCloneableDirectionParameters" "', argument " "1"" of type '" "mem::ScopedCloneablePtr< six::sicd::DirectionParameters > const &""'"); } if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ScopedCloneableAreaDirectionParameters" "', argument " "1"" of type '" "mem::ScopedCopyablePtr< six::sicd::AreaDirectionParameters > const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ScopedCloneableDirectionParameters" "', argument " "1"" of type '" "mem::ScopedCloneablePtr< six::sicd::DirectionParameters > const &""'"); } - arg1 = reinterpret_cast< mem::ScopedCopyablePtr< six::sicd::AreaDirectionParameters > * >(argp1); + arg1 = reinterpret_cast< mem::ScopedCloneablePtr< six::sicd::DirectionParameters > * >(argp1); { try { - result = (mem::ScopedCopyablePtr< six::sicd::AreaDirectionParameters > *)new mem::ScopedCopyablePtr< six::sicd::AreaDirectionParameters >((mem::ScopedCopyablePtr< six::sicd::AreaDirectionParameters > const &)*arg1); + result = (mem::ScopedCloneablePtr< six::sicd::DirectionParameters > *)new mem::ScopedCloneablePtr< six::sicd::DirectionParameters >((mem::ScopedCloneablePtr< six::sicd::DirectionParameters > const &)*arg1); } catch (const std::exception& e) { @@ -81419,14 +81418,14 @@ SWIGINTERN PyObject *_wrap_new_ScopedCloneableAreaDirectionParameters__SWIG_2(Py SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mem__ScopedCopyablePtrT_six__sicd__AreaDirectionParameters_t, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__DirectionParameters_t, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_ScopedCloneableAreaDirectionParameters(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_new_ScopedCloneableDirectionParameters(PyObject *self, PyObject *args) { int argc; PyObject *argv[2]; int ii; @@ -81437,54 +81436,54 @@ SWIGINTERN PyObject *_wrap_new_ScopedCloneableAreaDirectionParameters(PyObject * argv[ii] = PyTuple_GET_ITEM(args,ii); } if (argc == 0) { - return _wrap_new_ScopedCloneableAreaDirectionParameters__SWIG_1(self, args); + return _wrap_new_ScopedCloneableDirectionParameters__SWIG_1(self, args); } if (argc == 1) { int _v; void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_six__sicd__AreaDirectionParameters, 0); + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_six__sicd__DirectionParameters, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_ScopedCloneableAreaDirectionParameters__SWIG_0(self, args); + return _wrap_new_ScopedCloneableDirectionParameters__SWIG_0(self, args); } } if (argc == 1) { int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mem__ScopedCopyablePtrT_six__sicd__AreaDirectionParameters_t, 0); + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__DirectionParameters_t, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_ScopedCloneableAreaDirectionParameters__SWIG_2(self, args); + return _wrap_new_ScopedCloneableDirectionParameters__SWIG_2(self, args); } } fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ScopedCloneableAreaDirectionParameters'.\n" + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ScopedCloneableDirectionParameters'.\n" " Possible C/C++ prototypes are:\n" - " mem::ScopedCopyablePtr< six::sicd::AreaDirectionParameters >::ScopedCopyablePtr(six::sicd::AreaDirectionParameters *)\n" - " mem::ScopedCopyablePtr< six::sicd::AreaDirectionParameters >::ScopedCopyablePtr()\n" - " mem::ScopedCopyablePtr< six::sicd::AreaDirectionParameters >::ScopedCopyablePtr(mem::ScopedCopyablePtr< six::sicd::AreaDirectionParameters > const &)\n"); + " mem::ScopedCloneablePtr< six::sicd::DirectionParameters >::ScopedCloneablePtr(six::sicd::DirectionParameters *)\n" + " mem::ScopedCloneablePtr< six::sicd::DirectionParameters >::ScopedCloneablePtr()\n" + " mem::ScopedCloneablePtr< six::sicd::DirectionParameters >::ScopedCloneablePtr(mem::ScopedCloneablePtr< six::sicd::DirectionParameters > const &)\n"); return 0; } -SWIGINTERN PyObject *_wrap_ScopedCloneableAreaDirectionParameters_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ScopedCloneableDirectionParameters_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mem::ScopedCopyablePtr< six::sicd::AreaDirectionParameters > *arg1 = (mem::ScopedCopyablePtr< six::sicd::AreaDirectionParameters > *) 0 ; + mem::ScopedCloneablePtr< six::sicd::DirectionParameters > *arg1 = (mem::ScopedCloneablePtr< six::sicd::DirectionParameters > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; - six::sicd::AreaDirectionParameters *result = 0 ; + six::sicd::DirectionParameters *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:ScopedCloneableAreaDirectionParameters_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mem__ScopedCopyablePtrT_six__sicd__AreaDirectionParameters_t, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"O:ScopedCloneableDirectionParameters_get",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__DirectionParameters_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedCloneableAreaDirectionParameters_get" "', argument " "1"" of type '" "mem::ScopedCopyablePtr< six::sicd::AreaDirectionParameters > const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedCloneableDirectionParameters_get" "', argument " "1"" of type '" "mem::ScopedCloneablePtr< six::sicd::DirectionParameters > const *""'"); } - arg1 = reinterpret_cast< mem::ScopedCopyablePtr< six::sicd::AreaDirectionParameters > * >(argp1); + arg1 = reinterpret_cast< mem::ScopedCloneablePtr< six::sicd::DirectionParameters > * >(argp1); { try { - result = (six::sicd::AreaDirectionParameters *)((mem::ScopedCopyablePtr< six::sicd::AreaDirectionParameters > const *)arg1)->get(); + result = (six::sicd::DirectionParameters *)((mem::ScopedCloneablePtr< six::sicd::DirectionParameters > const *)arg1)->get(); } catch (const std::exception& e) { @@ -81512,31 +81511,31 @@ SWIGINTERN PyObject *_wrap_ScopedCloneableAreaDirectionParameters_get(PyObject * SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_six__sicd__AreaDirectionParameters, 0 | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_six__sicd__DirectionParameters, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_ScopedCloneableAreaDirectionParameters___ref__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ScopedCloneableDirectionParameters___ref__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mem::ScopedCopyablePtr< six::sicd::AreaDirectionParameters > *arg1 = (mem::ScopedCopyablePtr< six::sicd::AreaDirectionParameters > *) 0 ; + mem::ScopedCloneablePtr< six::sicd::DirectionParameters > *arg1 = (mem::ScopedCloneablePtr< six::sicd::DirectionParameters > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; - six::sicd::AreaDirectionParameters *result = 0 ; + six::sicd::DirectionParameters *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:ScopedCloneableAreaDirectionParameters___ref__",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mem__ScopedCopyablePtrT_six__sicd__AreaDirectionParameters_t, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"O:ScopedCloneableDirectionParameters___ref__",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__DirectionParameters_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedCloneableAreaDirectionParameters___ref__" "', argument " "1"" of type '" "mem::ScopedCopyablePtr< six::sicd::AreaDirectionParameters > const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedCloneableDirectionParameters___ref__" "', argument " "1"" of type '" "mem::ScopedCloneablePtr< six::sicd::DirectionParameters > const *""'"); } - arg1 = reinterpret_cast< mem::ScopedCopyablePtr< six::sicd::AreaDirectionParameters > * >(argp1); + arg1 = reinterpret_cast< mem::ScopedCloneablePtr< six::sicd::DirectionParameters > * >(argp1); { try { - result = (six::sicd::AreaDirectionParameters *) &((mem::ScopedCopyablePtr< six::sicd::AreaDirectionParameters > const *)arg1)->operator *(); + result = (six::sicd::DirectionParameters *) &((mem::ScopedCloneablePtr< six::sicd::DirectionParameters > const *)arg1)->operator *(); } catch (const std::exception& e) { @@ -81564,31 +81563,31 @@ SWIGINTERN PyObject *_wrap_ScopedCloneableAreaDirectionParameters___ref__(PyObje SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_six__sicd__AreaDirectionParameters, 0 | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_six__sicd__DirectionParameters, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_ScopedCloneableAreaDirectionParameters___deref__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ScopedCloneableDirectionParameters___deref__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mem::ScopedCopyablePtr< six::sicd::AreaDirectionParameters > *arg1 = (mem::ScopedCopyablePtr< six::sicd::AreaDirectionParameters > *) 0 ; + mem::ScopedCloneablePtr< six::sicd::DirectionParameters > *arg1 = (mem::ScopedCloneablePtr< six::sicd::DirectionParameters > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; - six::sicd::AreaDirectionParameters *result = 0 ; + six::sicd::DirectionParameters *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:ScopedCloneableAreaDirectionParameters___deref__",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mem__ScopedCopyablePtrT_six__sicd__AreaDirectionParameters_t, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"O:ScopedCloneableDirectionParameters___deref__",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__DirectionParameters_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedCloneableAreaDirectionParameters___deref__" "', argument " "1"" of type '" "mem::ScopedCopyablePtr< six::sicd::AreaDirectionParameters > const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedCloneableDirectionParameters___deref__" "', argument " "1"" of type '" "mem::ScopedCloneablePtr< six::sicd::DirectionParameters > const *""'"); } - arg1 = reinterpret_cast< mem::ScopedCopyablePtr< six::sicd::AreaDirectionParameters > * >(argp1); + arg1 = reinterpret_cast< mem::ScopedCloneablePtr< six::sicd::DirectionParameters > * >(argp1); { try { - result = (six::sicd::AreaDirectionParameters *)((mem::ScopedCopyablePtr< six::sicd::AreaDirectionParameters > const *)arg1)->operator ->(); + result = (six::sicd::DirectionParameters *)((mem::ScopedCloneablePtr< six::sicd::DirectionParameters > const *)arg1)->operator ->(); } catch (const std::exception& e) { @@ -81616,17 +81615,17 @@ SWIGINTERN PyObject *_wrap_ScopedCloneableAreaDirectionParameters___deref__(PyOb SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_six__sicd__AreaDirectionParameters, 0 | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_six__sicd__DirectionParameters, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_ScopedCloneableAreaDirectionParameters_reset__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ScopedCloneableDirectionParameters_reset__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mem::ScopedCopyablePtr< six::sicd::AreaDirectionParameters > *arg1 = (mem::ScopedCopyablePtr< six::sicd::AreaDirectionParameters > *) 0 ; - six::sicd::AreaDirectionParameters *arg2 = (six::sicd::AreaDirectionParameters *) 0 ; + mem::ScopedCloneablePtr< six::sicd::DirectionParameters > *arg1 = (mem::ScopedCloneablePtr< six::sicd::DirectionParameters > *) 0 ; + six::sicd::DirectionParameters *arg2 = (six::sicd::DirectionParameters *) 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -81634,17 +81633,17 @@ SWIGINTERN PyObject *_wrap_ScopedCloneableAreaDirectionParameters_reset__SWIG_0( PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; - if (!PyArg_ParseTuple(args,(char *)"OO:ScopedCloneableAreaDirectionParameters_reset",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mem__ScopedCopyablePtrT_six__sicd__AreaDirectionParameters_t, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"OO:ScopedCloneableDirectionParameters_reset",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__DirectionParameters_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedCloneableAreaDirectionParameters_reset" "', argument " "1"" of type '" "mem::ScopedCopyablePtr< six::sicd::AreaDirectionParameters > *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedCloneableDirectionParameters_reset" "', argument " "1"" of type '" "mem::ScopedCloneablePtr< six::sicd::DirectionParameters > *""'"); } - arg1 = reinterpret_cast< mem::ScopedCopyablePtr< six::sicd::AreaDirectionParameters > * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_six__sicd__AreaDirectionParameters, 0 | 0 ); + arg1 = reinterpret_cast< mem::ScopedCloneablePtr< six::sicd::DirectionParameters > * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_six__sicd__DirectionParameters, 0 | 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScopedCloneableAreaDirectionParameters_reset" "', argument " "2"" of type '" "six::sicd::AreaDirectionParameters *""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScopedCloneableDirectionParameters_reset" "', argument " "2"" of type '" "six::sicd::DirectionParameters *""'"); } - arg2 = reinterpret_cast< six::sicd::AreaDirectionParameters * >(argp2); + arg2 = reinterpret_cast< six::sicd::DirectionParameters * >(argp2); { try { @@ -81683,19 +81682,19 @@ SWIGINTERN PyObject *_wrap_ScopedCloneableAreaDirectionParameters_reset__SWIG_0( } -SWIGINTERN PyObject *_wrap_ScopedCloneableAreaDirectionParameters_reset__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ScopedCloneableDirectionParameters_reset__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mem::ScopedCopyablePtr< six::sicd::AreaDirectionParameters > *arg1 = (mem::ScopedCopyablePtr< six::sicd::AreaDirectionParameters > *) 0 ; + mem::ScopedCloneablePtr< six::sicd::DirectionParameters > *arg1 = (mem::ScopedCloneablePtr< six::sicd::DirectionParameters > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:ScopedCloneableAreaDirectionParameters_reset",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mem__ScopedCopyablePtrT_six__sicd__AreaDirectionParameters_t, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"O:ScopedCloneableDirectionParameters_reset",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__DirectionParameters_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedCloneableAreaDirectionParameters_reset" "', argument " "1"" of type '" "mem::ScopedCopyablePtr< six::sicd::AreaDirectionParameters > *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedCloneableDirectionParameters_reset" "', argument " "1"" of type '" "mem::ScopedCloneablePtr< six::sicd::DirectionParameters > *""'"); } - arg1 = reinterpret_cast< mem::ScopedCopyablePtr< six::sicd::AreaDirectionParameters > * >(argp1); + arg1 = reinterpret_cast< mem::ScopedCloneablePtr< six::sicd::DirectionParameters > * >(argp1); { try { @@ -81734,7 +81733,7 @@ SWIGINTERN PyObject *_wrap_ScopedCloneableAreaDirectionParameters_reset__SWIG_1( } -SWIGINTERN PyObject *_wrap_ScopedCloneableAreaDirectionParameters_reset(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_ScopedCloneableDirectionParameters_reset(PyObject *self, PyObject *args) { int argc; PyObject *argv[3]; int ii; @@ -81747,49 +81746,49 @@ SWIGINTERN PyObject *_wrap_ScopedCloneableAreaDirectionParameters_reset(PyObject if (argc == 1) { int _v; void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mem__ScopedCopyablePtrT_six__sicd__AreaDirectionParameters_t, 0); + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__DirectionParameters_t, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_ScopedCloneableAreaDirectionParameters_reset__SWIG_1(self, args); + return _wrap_ScopedCloneableDirectionParameters_reset__SWIG_1(self, args); } } if (argc == 2) { int _v; void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mem__ScopedCopyablePtrT_six__sicd__AreaDirectionParameters_t, 0); + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__DirectionParameters_t, 0); _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_six__sicd__AreaDirectionParameters, 0); + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_six__sicd__DirectionParameters, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_ScopedCloneableAreaDirectionParameters_reset__SWIG_0(self, args); + return _wrap_ScopedCloneableDirectionParameters_reset__SWIG_0(self, args); } } } fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ScopedCloneableAreaDirectionParameters_reset'.\n" + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ScopedCloneableDirectionParameters_reset'.\n" " Possible C/C++ prototypes are:\n" - " mem::ScopedCopyablePtr< six::sicd::AreaDirectionParameters >::reset(six::sicd::AreaDirectionParameters *)\n" - " mem::ScopedCopyablePtr< six::sicd::AreaDirectionParameters >::reset()\n"); + " mem::ScopedCloneablePtr< six::sicd::DirectionParameters >::reset(six::sicd::DirectionParameters *)\n" + " mem::ScopedCloneablePtr< six::sicd::DirectionParameters >::reset()\n"); return 0; } -SWIGINTERN PyObject *_wrap_delete_ScopedCloneableAreaDirectionParameters(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_ScopedCloneableDirectionParameters(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mem::ScopedCopyablePtr< six::sicd::AreaDirectionParameters > *arg1 = (mem::ScopedCopyablePtr< six::sicd::AreaDirectionParameters > *) 0 ; + mem::ScopedCloneablePtr< six::sicd::DirectionParameters > *arg1 = (mem::ScopedCloneablePtr< six::sicd::DirectionParameters > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:delete_ScopedCloneableAreaDirectionParameters",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mem__ScopedCopyablePtrT_six__sicd__AreaDirectionParameters_t, SWIG_POINTER_DISOWN | 0 ); + if (!PyArg_ParseTuple(args,(char *)"O:delete_ScopedCloneableDirectionParameters",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__DirectionParameters_t, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ScopedCloneableAreaDirectionParameters" "', argument " "1"" of type '" "mem::ScopedCopyablePtr< six::sicd::AreaDirectionParameters > *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ScopedCloneableDirectionParameters" "', argument " "1"" of type '" "mem::ScopedCloneablePtr< six::sicd::DirectionParameters > *""'"); } - arg1 = reinterpret_cast< mem::ScopedCopyablePtr< six::sicd::AreaDirectionParameters > * >(argp1); + arg1 = reinterpret_cast< mem::ScopedCloneablePtr< six::sicd::DirectionParameters > * >(argp1); { try { @@ -81828,24 +81827,24 @@ SWIGINTERN PyObject *_wrap_delete_ScopedCloneableAreaDirectionParameters(PyObjec } -SWIGINTERN PyObject *_wrap_ScopedCloneableAreaDirectionParameters_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ScopedCloneableDirectionParameters_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mem::ScopedCopyablePtr< six::sicd::AreaDirectionParameters > *arg1 = (mem::ScopedCopyablePtr< six::sicd::AreaDirectionParameters > *) 0 ; + mem::ScopedCloneablePtr< six::sicd::DirectionParameters > *arg1 = (mem::ScopedCloneablePtr< six::sicd::DirectionParameters > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; - six::sicd::AreaDirectionParameters *result = 0 ; + six::sicd::DirectionParameters *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:ScopedCloneableAreaDirectionParameters_clone",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mem__ScopedCopyablePtrT_six__sicd__AreaDirectionParameters_t, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"O:ScopedCloneableDirectionParameters_clone",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__DirectionParameters_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedCloneableAreaDirectionParameters_clone" "', argument " "1"" of type '" "mem::ScopedCopyablePtr< six::sicd::AreaDirectionParameters > const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedCloneableDirectionParameters_clone" "', argument " "1"" of type '" "mem::ScopedCloneablePtr< six::sicd::DirectionParameters > const *""'"); } - arg1 = reinterpret_cast< mem::ScopedCopyablePtr< six::sicd::AreaDirectionParameters > * >(argp1); + arg1 = reinterpret_cast< mem::ScopedCloneablePtr< six::sicd::DirectionParameters > * >(argp1); { try { - result = (six::sicd::AreaDirectionParameters *)(*arg1)->clone(); + result = (six::sicd::DirectionParameters *)(*arg1)->clone(); } catch (const std::exception& e) { @@ -81873,16 +81872,16 @@ SWIGINTERN PyObject *_wrap_ScopedCloneableAreaDirectionParameters_clone(PyObject SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_six__sicd__AreaDirectionParameters, 0 | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_six__sicd__DirectionParameters, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_ScopedCloneableAreaDirectionParameters_unitVector_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ScopedCloneableDirectionParameters_unitVector_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mem::ScopedCopyablePtr< six::sicd::AreaDirectionParameters > *arg1 = (mem::ScopedCopyablePtr< six::sicd::AreaDirectionParameters > *) 0 ; + mem::ScopedCloneablePtr< six::sicd::DirectionParameters > *arg1 = (mem::ScopedCloneablePtr< six::sicd::DirectionParameters > *) 0 ; six::Vector3 *arg2 = (six::Vector3 *) 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -81891,15 +81890,15 @@ SWIGINTERN PyObject *_wrap_ScopedCloneableAreaDirectionParameters_unitVector_set PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; - if (!PyArg_ParseTuple(args,(char *)"OO:ScopedCloneableAreaDirectionParameters_unitVector_set",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mem__ScopedCopyablePtrT_six__sicd__AreaDirectionParameters_t, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"OO:ScopedCloneableDirectionParameters_unitVector_set",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__DirectionParameters_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedCloneableAreaDirectionParameters_unitVector_set" "', argument " "1"" of type '" "mem::ScopedCopyablePtr< six::sicd::AreaDirectionParameters > *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedCloneableDirectionParameters_unitVector_set" "', argument " "1"" of type '" "mem::ScopedCloneablePtr< six::sicd::DirectionParameters > *""'"); } - arg1 = reinterpret_cast< mem::ScopedCopyablePtr< six::sicd::AreaDirectionParameters > * >(argp1); + arg1 = reinterpret_cast< mem::ScopedCloneablePtr< six::sicd::DirectionParameters > * >(argp1); res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_math__linear__VectorNT_3_double_t, 0 | 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScopedCloneableAreaDirectionParameters_unitVector_set" "', argument " "2"" of type '" "six::Vector3 *""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScopedCloneableDirectionParameters_unitVector_set" "', argument " "2"" of type '" "six::Vector3 *""'"); } arg2 = reinterpret_cast< six::Vector3 * >(argp2); { @@ -81940,20 +81939,20 @@ SWIGINTERN PyObject *_wrap_ScopedCloneableAreaDirectionParameters_unitVector_set } -SWIGINTERN PyObject *_wrap_ScopedCloneableAreaDirectionParameters_unitVector_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ScopedCloneableDirectionParameters_unitVector_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mem::ScopedCopyablePtr< six::sicd::AreaDirectionParameters > *arg1 = (mem::ScopedCopyablePtr< six::sicd::AreaDirectionParameters > *) 0 ; + mem::ScopedCloneablePtr< six::sicd::DirectionParameters > *arg1 = (mem::ScopedCloneablePtr< six::sicd::DirectionParameters > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; six::Vector3 *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:ScopedCloneableAreaDirectionParameters_unitVector_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mem__ScopedCopyablePtrT_six__sicd__AreaDirectionParameters_t, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"O:ScopedCloneableDirectionParameters_unitVector_get",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__DirectionParameters_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedCloneableAreaDirectionParameters_unitVector_get" "', argument " "1"" of type '" "mem::ScopedCopyablePtr< six::sicd::AreaDirectionParameters > *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedCloneableDirectionParameters_unitVector_get" "', argument " "1"" of type '" "mem::ScopedCloneablePtr< six::sicd::DirectionParameters > *""'"); } - arg1 = reinterpret_cast< mem::ScopedCopyablePtr< six::sicd::AreaDirectionParameters > * >(argp1); + arg1 = reinterpret_cast< mem::ScopedCloneablePtr< six::sicd::DirectionParameters > * >(argp1); { try { @@ -81992,9 +81991,9 @@ SWIGINTERN PyObject *_wrap_ScopedCloneableAreaDirectionParameters_unitVector_get } -SWIGINTERN PyObject *_wrap_ScopedCloneableAreaDirectionParameters_spacing_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ScopedCloneableDirectionParameters_sampleSpacing_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mem::ScopedCopyablePtr< six::sicd::AreaDirectionParameters > *arg1 = (mem::ScopedCopyablePtr< six::sicd::AreaDirectionParameters > *) 0 ; + mem::ScopedCloneablePtr< six::sicd::DirectionParameters > *arg1 = (mem::ScopedCloneablePtr< six::sicd::DirectionParameters > *) 0 ; double arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -82003,21 +82002,21 @@ SWIGINTERN PyObject *_wrap_ScopedCloneableAreaDirectionParameters_spacing_set(Py PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; - if (!PyArg_ParseTuple(args,(char *)"OO:ScopedCloneableAreaDirectionParameters_spacing_set",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mem__ScopedCopyablePtrT_six__sicd__AreaDirectionParameters_t, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"OO:ScopedCloneableDirectionParameters_sampleSpacing_set",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__DirectionParameters_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedCloneableAreaDirectionParameters_spacing_set" "', argument " "1"" of type '" "mem::ScopedCopyablePtr< six::sicd::AreaDirectionParameters > *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedCloneableDirectionParameters_sampleSpacing_set" "', argument " "1"" of type '" "mem::ScopedCloneablePtr< six::sicd::DirectionParameters > *""'"); } - arg1 = reinterpret_cast< mem::ScopedCopyablePtr< six::sicd::AreaDirectionParameters > * >(argp1); + arg1 = reinterpret_cast< mem::ScopedCloneablePtr< six::sicd::DirectionParameters > * >(argp1); ecode2 = SWIG_AsVal_double(obj1, &val2); if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScopedCloneableAreaDirectionParameters_spacing_set" "', argument " "2"" of type '" "double""'"); + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScopedCloneableDirectionParameters_sampleSpacing_set" "', argument " "2"" of type '" "double""'"); } arg2 = static_cast< double >(val2); { try { - if (arg1) (*arg1)->spacing = arg2; + if (arg1) (*arg1)->sampleSpacing = arg2; } catch (const std::exception& e) { @@ -82052,24 +82051,24 @@ SWIGINTERN PyObject *_wrap_ScopedCloneableAreaDirectionParameters_spacing_set(Py } -SWIGINTERN PyObject *_wrap_ScopedCloneableAreaDirectionParameters_spacing_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ScopedCloneableDirectionParameters_sampleSpacing_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mem::ScopedCopyablePtr< six::sicd::AreaDirectionParameters > *arg1 = (mem::ScopedCopyablePtr< six::sicd::AreaDirectionParameters > *) 0 ; + mem::ScopedCloneablePtr< six::sicd::DirectionParameters > *arg1 = (mem::ScopedCloneablePtr< six::sicd::DirectionParameters > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; double result; - if (!PyArg_ParseTuple(args,(char *)"O:ScopedCloneableAreaDirectionParameters_spacing_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mem__ScopedCopyablePtrT_six__sicd__AreaDirectionParameters_t, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"O:ScopedCloneableDirectionParameters_sampleSpacing_get",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__DirectionParameters_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedCloneableAreaDirectionParameters_spacing_get" "', argument " "1"" of type '" "mem::ScopedCopyablePtr< six::sicd::AreaDirectionParameters > *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedCloneableDirectionParameters_sampleSpacing_get" "', argument " "1"" of type '" "mem::ScopedCloneablePtr< six::sicd::DirectionParameters > *""'"); } - arg1 = reinterpret_cast< mem::ScopedCopyablePtr< six::sicd::AreaDirectionParameters > * >(argp1); + arg1 = reinterpret_cast< mem::ScopedCloneablePtr< six::sicd::DirectionParameters > * >(argp1); { try { - result = (double) ((*arg1)->spacing); + result = (double) ((*arg1)->sampleSpacing); } catch (const std::exception& e) { @@ -82104,32 +82103,32 @@ SWIGINTERN PyObject *_wrap_ScopedCloneableAreaDirectionParameters_spacing_get(Py } -SWIGINTERN PyObject *_wrap_ScopedCloneableAreaDirectionParameters_elements_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ScopedCloneableDirectionParameters_impulseResponseWidth_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mem::ScopedCopyablePtr< six::sicd::AreaDirectionParameters > *arg1 = (mem::ScopedCopyablePtr< six::sicd::AreaDirectionParameters > *) 0 ; - size_t arg2 ; + mem::ScopedCloneablePtr< six::sicd::DirectionParameters > *arg1 = (mem::ScopedCloneablePtr< six::sicd::DirectionParameters > *) 0 ; + double arg2 ; void *argp1 = 0 ; int res1 = 0 ; - size_t val2 ; + double val2 ; int ecode2 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; - if (!PyArg_ParseTuple(args,(char *)"OO:ScopedCloneableAreaDirectionParameters_elements_set",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mem__ScopedCopyablePtrT_six__sicd__AreaDirectionParameters_t, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"OO:ScopedCloneableDirectionParameters_impulseResponseWidth_set",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__DirectionParameters_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedCloneableAreaDirectionParameters_elements_set" "', argument " "1"" of type '" "mem::ScopedCopyablePtr< six::sicd::AreaDirectionParameters > *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedCloneableDirectionParameters_impulseResponseWidth_set" "', argument " "1"" of type '" "mem::ScopedCloneablePtr< six::sicd::DirectionParameters > *""'"); } - arg1 = reinterpret_cast< mem::ScopedCopyablePtr< six::sicd::AreaDirectionParameters > * >(argp1); - ecode2 = SWIG_AsVal_size_t(obj1, &val2); + arg1 = reinterpret_cast< mem::ScopedCloneablePtr< six::sicd::DirectionParameters > * >(argp1); + ecode2 = SWIG_AsVal_double(obj1, &val2); if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScopedCloneableAreaDirectionParameters_elements_set" "', argument " "2"" of type '" "size_t""'"); + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScopedCloneableDirectionParameters_impulseResponseWidth_set" "', argument " "2"" of type '" "double""'"); } - arg2 = static_cast< size_t >(val2); + arg2 = static_cast< double >(val2); { try { - if (arg1) (*arg1)->elements = arg2; + if (arg1) (*arg1)->impulseResponseWidth = arg2; } catch (const std::exception& e) { @@ -82164,24 +82163,24 @@ SWIGINTERN PyObject *_wrap_ScopedCloneableAreaDirectionParameters_elements_set(P } -SWIGINTERN PyObject *_wrap_ScopedCloneableAreaDirectionParameters_elements_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ScopedCloneableDirectionParameters_impulseResponseWidth_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mem::ScopedCopyablePtr< six::sicd::AreaDirectionParameters > *arg1 = (mem::ScopedCopyablePtr< six::sicd::AreaDirectionParameters > *) 0 ; + mem::ScopedCloneablePtr< six::sicd::DirectionParameters > *arg1 = (mem::ScopedCloneablePtr< six::sicd::DirectionParameters > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; - size_t result; + double result; - if (!PyArg_ParseTuple(args,(char *)"O:ScopedCloneableAreaDirectionParameters_elements_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mem__ScopedCopyablePtrT_six__sicd__AreaDirectionParameters_t, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"O:ScopedCloneableDirectionParameters_impulseResponseWidth_get",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__DirectionParameters_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedCloneableAreaDirectionParameters_elements_get" "', argument " "1"" of type '" "mem::ScopedCopyablePtr< six::sicd::AreaDirectionParameters > *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedCloneableDirectionParameters_impulseResponseWidth_get" "', argument " "1"" of type '" "mem::ScopedCloneablePtr< six::sicd::DirectionParameters > *""'"); } - arg1 = reinterpret_cast< mem::ScopedCopyablePtr< six::sicd::AreaDirectionParameters > * >(argp1); + arg1 = reinterpret_cast< mem::ScopedCloneablePtr< six::sicd::DirectionParameters > * >(argp1); { try { - result = ((*arg1)->elements); + result = (double) ((*arg1)->impulseResponseWidth); } catch (const std::exception& e) { @@ -82209,39 +82208,39 @@ SWIGINTERN PyObject *_wrap_ScopedCloneableAreaDirectionParameters_elements_get(P SWIG_fail; } } - resultobj = SWIG_From_size_t(static_cast< size_t >(result)); + resultobj = SWIG_From_double(static_cast< double >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_ScopedCloneableAreaDirectionParameters_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ScopedCloneableDirectionParameters_sign_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mem::ScopedCopyablePtr< six::sicd::AreaDirectionParameters > *arg1 = (mem::ScopedCopyablePtr< six::sicd::AreaDirectionParameters > *) 0 ; - size_t arg2 ; + mem::ScopedCloneablePtr< six::sicd::DirectionParameters > *arg1 = (mem::ScopedCloneablePtr< six::sicd::DirectionParameters > *) 0 ; + six::FFTSign *arg2 = (six::FFTSign *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - size_t val2 ; - int ecode2 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; - if (!PyArg_ParseTuple(args,(char *)"OO:ScopedCloneableAreaDirectionParameters_first_set",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mem__ScopedCopyablePtrT_six__sicd__AreaDirectionParameters_t, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"OO:ScopedCloneableDirectionParameters_sign_set",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__DirectionParameters_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedCloneableAreaDirectionParameters_first_set" "', argument " "1"" of type '" "mem::ScopedCopyablePtr< six::sicd::AreaDirectionParameters > *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedCloneableDirectionParameters_sign_set" "', argument " "1"" of type '" "mem::ScopedCloneablePtr< six::sicd::DirectionParameters > *""'"); } - arg1 = reinterpret_cast< mem::ScopedCopyablePtr< six::sicd::AreaDirectionParameters > * >(argp1); - ecode2 = SWIG_AsVal_size_t(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScopedCloneableAreaDirectionParameters_first_set" "', argument " "2"" of type '" "size_t""'"); - } - arg2 = static_cast< size_t >(val2); + arg1 = reinterpret_cast< mem::ScopedCloneablePtr< six::sicd::DirectionParameters > * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_six__FFTSign, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScopedCloneableDirectionParameters_sign_set" "', argument " "2"" of type '" "six::FFTSign *""'"); + } + arg2 = reinterpret_cast< six::FFTSign * >(argp2); { try { - if (arg1) (*arg1)->first = arg2; + if (arg1) (*arg1)->sign = *arg2; } catch (const std::exception& e) { @@ -82276,24 +82275,24 @@ SWIGINTERN PyObject *_wrap_ScopedCloneableAreaDirectionParameters_first_set(PyOb } -SWIGINTERN PyObject *_wrap_ScopedCloneableAreaDirectionParameters_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ScopedCloneableDirectionParameters_sign_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mem::ScopedCopyablePtr< six::sicd::AreaDirectionParameters > *arg1 = (mem::ScopedCopyablePtr< six::sicd::AreaDirectionParameters > *) 0 ; + mem::ScopedCloneablePtr< six::sicd::DirectionParameters > *arg1 = (mem::ScopedCloneablePtr< six::sicd::DirectionParameters > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; - size_t result; + six::FFTSign *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:ScopedCloneableAreaDirectionParameters_first_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mem__ScopedCopyablePtrT_six__sicd__AreaDirectionParameters_t, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"O:ScopedCloneableDirectionParameters_sign_get",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__DirectionParameters_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedCloneableAreaDirectionParameters_first_get" "', argument " "1"" of type '" "mem::ScopedCopyablePtr< six::sicd::AreaDirectionParameters > *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedCloneableDirectionParameters_sign_get" "', argument " "1"" of type '" "mem::ScopedCloneablePtr< six::sicd::DirectionParameters > *""'"); } - arg1 = reinterpret_cast< mem::ScopedCopyablePtr< six::sicd::AreaDirectionParameters > * >(argp1); + arg1 = reinterpret_cast< mem::ScopedCloneablePtr< six::sicd::DirectionParameters > * >(argp1); { try { - result = ((*arg1)->first); + result = (six::FFTSign *)& ((*arg1)->sign); } catch (const std::exception& e) { @@ -82321,43 +82320,39 @@ SWIGINTERN PyObject *_wrap_ScopedCloneableAreaDirectionParameters_first_get(PyOb SWIG_fail; } } - resultobj = SWIG_From_size_t(static_cast< size_t >(result)); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_six__FFTSign, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_ScopedCloneableAreaDirectionParameters___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ScopedCloneableDirectionParameters_impulseResponseBandwidth_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mem::ScopedCopyablePtr< six::sicd::AreaDirectionParameters > *arg1 = (mem::ScopedCopyablePtr< six::sicd::AreaDirectionParameters > *) 0 ; - six::sicd::AreaDirectionParameters *arg2 = 0 ; + mem::ScopedCloneablePtr< six::sicd::DirectionParameters > *arg1 = (mem::ScopedCloneablePtr< six::sicd::DirectionParameters > *) 0 ; + double arg2 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; + double val2 ; + int ecode2 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; - bool result; - if (!PyArg_ParseTuple(args,(char *)"OO:ScopedCloneableAreaDirectionParameters___eq__",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mem__ScopedCopyablePtrT_six__sicd__AreaDirectionParameters_t, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"OO:ScopedCloneableDirectionParameters_impulseResponseBandwidth_set",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__DirectionParameters_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedCloneableAreaDirectionParameters___eq__" "', argument " "1"" of type '" "mem::ScopedCopyablePtr< six::sicd::AreaDirectionParameters > const *""'"); - } - arg1 = reinterpret_cast< mem::ScopedCopyablePtr< six::sicd::AreaDirectionParameters > * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_six__sicd__AreaDirectionParameters, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScopedCloneableAreaDirectionParameters___eq__" "', argument " "2"" of type '" "six::sicd::AreaDirectionParameters const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ScopedCloneableAreaDirectionParameters___eq__" "', argument " "2"" of type '" "six::sicd::AreaDirectionParameters const &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedCloneableDirectionParameters_impulseResponseBandwidth_set" "', argument " "1"" of type '" "mem::ScopedCloneablePtr< six::sicd::DirectionParameters > *""'"); } - arg2 = reinterpret_cast< six::sicd::AreaDirectionParameters * >(argp2); + arg1 = reinterpret_cast< mem::ScopedCloneablePtr< six::sicd::DirectionParameters > * >(argp1); + ecode2 = SWIG_AsVal_double(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScopedCloneableDirectionParameters_impulseResponseBandwidth_set" "', argument " "2"" of type '" "double""'"); + } + arg2 = static_cast< double >(val2); { try { - result = (bool)(*arg1)->operator ==((six::sicd::AreaDirectionParameters const &)*arg2); + if (arg1) (*arg1)->impulseResponseBandwidth = arg2; } catch (const std::exception& e) { @@ -82385,43 +82380,31 @@ SWIGINTERN PyObject *_wrap_ScopedCloneableAreaDirectionParameters___eq__(PyObjec SWIG_fail; } } - resultobj = SWIG_From_bool(static_cast< bool >(result)); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_ScopedCloneableAreaDirectionParameters___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ScopedCloneableDirectionParameters_impulseResponseBandwidth_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mem::ScopedCopyablePtr< six::sicd::AreaDirectionParameters > *arg1 = (mem::ScopedCopyablePtr< six::sicd::AreaDirectionParameters > *) 0 ; - six::sicd::AreaDirectionParameters *arg2 = 0 ; + mem::ScopedCloneablePtr< six::sicd::DirectionParameters > *arg1 = (mem::ScopedCloneablePtr< six::sicd::DirectionParameters > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - bool result; + double result; - if (!PyArg_ParseTuple(args,(char *)"OO:ScopedCloneableAreaDirectionParameters___ne__",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mem__ScopedCopyablePtrT_six__sicd__AreaDirectionParameters_t, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"O:ScopedCloneableDirectionParameters_impulseResponseBandwidth_get",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__DirectionParameters_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedCloneableAreaDirectionParameters___ne__" "', argument " "1"" of type '" "mem::ScopedCopyablePtr< six::sicd::AreaDirectionParameters > const *""'"); - } - arg1 = reinterpret_cast< mem::ScopedCopyablePtr< six::sicd::AreaDirectionParameters > * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_six__sicd__AreaDirectionParameters, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScopedCloneableAreaDirectionParameters___ne__" "', argument " "2"" of type '" "six::sicd::AreaDirectionParameters const &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedCloneableDirectionParameters_impulseResponseBandwidth_get" "', argument " "1"" of type '" "mem::ScopedCloneablePtr< six::sicd::DirectionParameters > *""'"); } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ScopedCloneableAreaDirectionParameters___ne__" "', argument " "2"" of type '" "six::sicd::AreaDirectionParameters const &""'"); - } - arg2 = reinterpret_cast< six::sicd::AreaDirectionParameters * >(argp2); + arg1 = reinterpret_cast< mem::ScopedCloneablePtr< six::sicd::DirectionParameters > * >(argp1); { try { - result = (bool)(*arg1)->operator !=((six::sicd::AreaDirectionParameters const &)*arg2); + result = (double) ((*arg1)->impulseResponseBandwidth); } catch (const std::exception& e) { @@ -82449,38 +82432,39 @@ SWIGINTERN PyObject *_wrap_ScopedCloneableAreaDirectionParameters___ne__(PyObjec SWIG_fail; } } - resultobj = SWIG_From_bool(static_cast< bool >(result)); + resultobj = SWIG_From_double(static_cast< double >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *ScopedCloneableAreaDirectionParameters_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mem__ScopedCopyablePtrT_six__sicd__AreaDirectionParameters_t, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *_wrap_new_ScopedCloneableSegment__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ScopedCloneableDirectionParameters_kCenter_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - six::sicd::Segment *arg1 = (six::sicd::Segment *) 0 ; + mem::ScopedCloneablePtr< six::sicd::DirectionParameters > *arg1 = (mem::ScopedCloneablePtr< six::sicd::DirectionParameters > *) 0 ; + double arg2 ; void *argp1 = 0 ; int res1 = 0 ; + double val2 ; + int ecode2 = 0 ; PyObject * obj0 = 0 ; - mem::ScopedCloneablePtr< six::sicd::Segment > *result = 0 ; + PyObject * obj1 = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:new_ScopedCloneableSegment",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_six__sicd__Segment, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"OO:ScopedCloneableDirectionParameters_kCenter_set",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__DirectionParameters_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ScopedCloneableSegment" "', argument " "1"" of type '" "six::sicd::Segment *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedCloneableDirectionParameters_kCenter_set" "', argument " "1"" of type '" "mem::ScopedCloneablePtr< six::sicd::DirectionParameters > *""'"); } - arg1 = reinterpret_cast< six::sicd::Segment * >(argp1); + arg1 = reinterpret_cast< mem::ScopedCloneablePtr< six::sicd::DirectionParameters > * >(argp1); + ecode2 = SWIG_AsVal_double(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScopedCloneableDirectionParameters_kCenter_set" "', argument " "2"" of type '" "double""'"); + } + arg2 = static_cast< double >(val2); { try { - result = (mem::ScopedCloneablePtr< six::sicd::Segment > *)new mem::ScopedCloneablePtr< six::sicd::Segment >(arg1); + if (arg1) (*arg1)->kCenter = arg2; } catch (const std::exception& e) { @@ -82508,22 +82492,31 @@ SWIGINTERN PyObject *_wrap_new_ScopedCloneableSegment__SWIG_0(PyObject *SWIGUNUS SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__Segment_t, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_ScopedCloneableSegment__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ScopedCloneableDirectionParameters_kCenter_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mem::ScopedCloneablePtr< six::sicd::Segment > *result = 0 ; + mem::ScopedCloneablePtr< six::sicd::DirectionParameters > *arg1 = (mem::ScopedCloneablePtr< six::sicd::DirectionParameters > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + double result; - if (!PyArg_ParseTuple(args,(char *)":new_ScopedCloneableSegment")) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"O:ScopedCloneableDirectionParameters_kCenter_get",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__DirectionParameters_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedCloneableDirectionParameters_kCenter_get" "', argument " "1"" of type '" "mem::ScopedCloneablePtr< six::sicd::DirectionParameters > *""'"); + } + arg1 = reinterpret_cast< mem::ScopedCloneablePtr< six::sicd::DirectionParameters > * >(argp1); { try { - result = (mem::ScopedCloneablePtr< six::sicd::Segment > *)new mem::ScopedCloneablePtr< six::sicd::Segment >(); + result = (double) ((*arg1)->kCenter); } catch (const std::exception& e) { @@ -82551,34 +82544,39 @@ SWIGINTERN PyObject *_wrap_new_ScopedCloneableSegment__SWIG_1(PyObject *SWIGUNUS SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__Segment_t, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_From_double(static_cast< double >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_ScopedCloneableSegment__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ScopedCloneableDirectionParameters_deltaK1_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mem::ScopedCloneablePtr< six::sicd::Segment > *arg1 = 0 ; + mem::ScopedCloneablePtr< six::sicd::DirectionParameters > *arg1 = (mem::ScopedCloneablePtr< six::sicd::DirectionParameters > *) 0 ; + double arg2 ; void *argp1 = 0 ; int res1 = 0 ; + double val2 ; + int ecode2 = 0 ; PyObject * obj0 = 0 ; - mem::ScopedCloneablePtr< six::sicd::Segment > *result = 0 ; + PyObject * obj1 = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:new_ScopedCloneableSegment",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__Segment_t, 0 | 0); + if (!PyArg_ParseTuple(args,(char *)"OO:ScopedCloneableDirectionParameters_deltaK1_set",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__DirectionParameters_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ScopedCloneableSegment" "', argument " "1"" of type '" "mem::ScopedCloneablePtr< six::sicd::Segment > const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ScopedCloneableSegment" "', argument " "1"" of type '" "mem::ScopedCloneablePtr< six::sicd::Segment > const &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedCloneableDirectionParameters_deltaK1_set" "', argument " "1"" of type '" "mem::ScopedCloneablePtr< six::sicd::DirectionParameters > *""'"); } - arg1 = reinterpret_cast< mem::ScopedCloneablePtr< six::sicd::Segment > * >(argp1); + arg1 = reinterpret_cast< mem::ScopedCloneablePtr< six::sicd::DirectionParameters > * >(argp1); + ecode2 = SWIG_AsVal_double(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScopedCloneableDirectionParameters_deltaK1_set" "', argument " "2"" of type '" "double""'"); + } + arg2 = static_cast< double >(val2); { try { - result = (mem::ScopedCloneablePtr< six::sicd::Segment > *)new mem::ScopedCloneablePtr< six::sicd::Segment >((mem::ScopedCloneablePtr< six::sicd::Segment > const &)*arg1); + if (arg1) (*arg1)->deltaK1 = arg2; } catch (const std::exception& e) { @@ -82606,72 +82604,31 @@ SWIGINTERN PyObject *_wrap_new_ScopedCloneableSegment__SWIG_2(PyObject *SWIGUNUS SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__Segment_t, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_ScopedCloneableSegment(PyObject *self, PyObject *args) { - int argc; - PyObject *argv[2]; - int ii; - - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? (int)PyObject_Length(args) : 0; - for (ii = 0; (ii < 1) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } - if (argc == 0) { - return _wrap_new_ScopedCloneableSegment__SWIG_1(self, args); - } - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_six__sicd__Segment, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_ScopedCloneableSegment__SWIG_0(self, args); - } - } - if (argc == 1) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__Segment_t, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_ScopedCloneableSegment__SWIG_2(self, args); - } - } - -fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ScopedCloneableSegment'.\n" - " Possible C/C++ prototypes are:\n" - " mem::ScopedCloneablePtr< six::sicd::Segment >::ScopedCloneablePtr(six::sicd::Segment *)\n" - " mem::ScopedCloneablePtr< six::sicd::Segment >::ScopedCloneablePtr()\n" - " mem::ScopedCloneablePtr< six::sicd::Segment >::ScopedCloneablePtr(mem::ScopedCloneablePtr< six::sicd::Segment > const &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_ScopedCloneableSegment_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ScopedCloneableDirectionParameters_deltaK1_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mem::ScopedCloneablePtr< six::sicd::Segment > *arg1 = (mem::ScopedCloneablePtr< six::sicd::Segment > *) 0 ; + mem::ScopedCloneablePtr< six::sicd::DirectionParameters > *arg1 = (mem::ScopedCloneablePtr< six::sicd::DirectionParameters > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; - six::sicd::Segment *result = 0 ; + double result; - if (!PyArg_ParseTuple(args,(char *)"O:ScopedCloneableSegment_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__Segment_t, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"O:ScopedCloneableDirectionParameters_deltaK1_get",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__DirectionParameters_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedCloneableSegment_get" "', argument " "1"" of type '" "mem::ScopedCloneablePtr< six::sicd::Segment > const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedCloneableDirectionParameters_deltaK1_get" "', argument " "1"" of type '" "mem::ScopedCloneablePtr< six::sicd::DirectionParameters > *""'"); } - arg1 = reinterpret_cast< mem::ScopedCloneablePtr< six::sicd::Segment > * >(argp1); + arg1 = reinterpret_cast< mem::ScopedCloneablePtr< six::sicd::DirectionParameters > * >(argp1); { try { - result = (six::sicd::Segment *)((mem::ScopedCloneablePtr< six::sicd::Segment > const *)arg1)->get(); + result = (double) ((*arg1)->deltaK1); } catch (const std::exception& e) { @@ -82699,31 +82656,39 @@ SWIGINTERN PyObject *_wrap_ScopedCloneableSegment_get(PyObject *SWIGUNUSEDPARM(s SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_six__sicd__Segment, 0 | 0 ); + resultobj = SWIG_From_double(static_cast< double >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_ScopedCloneableSegment___ref__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ScopedCloneableDirectionParameters_deltaK2_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mem::ScopedCloneablePtr< six::sicd::Segment > *arg1 = (mem::ScopedCloneablePtr< six::sicd::Segment > *) 0 ; + mem::ScopedCloneablePtr< six::sicd::DirectionParameters > *arg1 = (mem::ScopedCloneablePtr< six::sicd::DirectionParameters > *) 0 ; + double arg2 ; void *argp1 = 0 ; int res1 = 0 ; + double val2 ; + int ecode2 = 0 ; PyObject * obj0 = 0 ; - six::sicd::Segment *result = 0 ; + PyObject * obj1 = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:ScopedCloneableSegment___ref__",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__Segment_t, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"OO:ScopedCloneableDirectionParameters_deltaK2_set",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__DirectionParameters_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedCloneableSegment___ref__" "', argument " "1"" of type '" "mem::ScopedCloneablePtr< six::sicd::Segment > const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedCloneableDirectionParameters_deltaK2_set" "', argument " "1"" of type '" "mem::ScopedCloneablePtr< six::sicd::DirectionParameters > *""'"); } - arg1 = reinterpret_cast< mem::ScopedCloneablePtr< six::sicd::Segment > * >(argp1); + arg1 = reinterpret_cast< mem::ScopedCloneablePtr< six::sicd::DirectionParameters > * >(argp1); + ecode2 = SWIG_AsVal_double(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScopedCloneableDirectionParameters_deltaK2_set" "', argument " "2"" of type '" "double""'"); + } + arg2 = static_cast< double >(val2); { try { - result = (six::sicd::Segment *) &((mem::ScopedCloneablePtr< six::sicd::Segment > const *)arg1)->operator *(); + if (arg1) (*arg1)->deltaK2 = arg2; } catch (const std::exception& e) { @@ -82751,31 +82716,31 @@ SWIGINTERN PyObject *_wrap_ScopedCloneableSegment___ref__(PyObject *SWIGUNUSEDPA SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_six__sicd__Segment, 0 | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_ScopedCloneableSegment___deref__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ScopedCloneableDirectionParameters_deltaK2_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mem::ScopedCloneablePtr< six::sicd::Segment > *arg1 = (mem::ScopedCloneablePtr< six::sicd::Segment > *) 0 ; + mem::ScopedCloneablePtr< six::sicd::DirectionParameters > *arg1 = (mem::ScopedCloneablePtr< six::sicd::DirectionParameters > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; - six::sicd::Segment *result = 0 ; + double result; - if (!PyArg_ParseTuple(args,(char *)"O:ScopedCloneableSegment___deref__",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__Segment_t, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"O:ScopedCloneableDirectionParameters_deltaK2_get",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__DirectionParameters_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedCloneableSegment___deref__" "', argument " "1"" of type '" "mem::ScopedCloneablePtr< six::sicd::Segment > const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedCloneableDirectionParameters_deltaK2_get" "', argument " "1"" of type '" "mem::ScopedCloneablePtr< six::sicd::DirectionParameters > *""'"); } - arg1 = reinterpret_cast< mem::ScopedCloneablePtr< six::sicd::Segment > * >(argp1); + arg1 = reinterpret_cast< mem::ScopedCloneablePtr< six::sicd::DirectionParameters > * >(argp1); { try { - result = (six::sicd::Segment *)((mem::ScopedCloneablePtr< six::sicd::Segment > const *)arg1)->operator ->(); + result = (double) ((*arg1)->deltaK2); } catch (const std::exception& e) { @@ -82803,17 +82768,17 @@ SWIGINTERN PyObject *_wrap_ScopedCloneableSegment___deref__(PyObject *SWIGUNUSED SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_six__sicd__Segment, 0 | 0 ); + resultobj = SWIG_From_double(static_cast< double >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_ScopedCloneableSegment_reset__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ScopedCloneableDirectionParameters_deltaKCOAPoly_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mem::ScopedCloneablePtr< six::sicd::Segment > *arg1 = (mem::ScopedCloneablePtr< six::sicd::Segment > *) 0 ; - six::sicd::Segment *arg2 = (six::sicd::Segment *) 0 ; + mem::ScopedCloneablePtr< six::sicd::DirectionParameters > *arg1 = (mem::ScopedCloneablePtr< six::sicd::DirectionParameters > *) 0 ; + six::Poly2D *arg2 = (six::Poly2D *) 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -82821,21 +82786,21 @@ SWIGINTERN PyObject *_wrap_ScopedCloneableSegment_reset__SWIG_0(PyObject *SWIGUN PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; - if (!PyArg_ParseTuple(args,(char *)"OO:ScopedCloneableSegment_reset",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__Segment_t, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"OO:ScopedCloneableDirectionParameters_deltaKCOAPoly_set",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__DirectionParameters_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedCloneableSegment_reset" "', argument " "1"" of type '" "mem::ScopedCloneablePtr< six::sicd::Segment > *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedCloneableDirectionParameters_deltaKCOAPoly_set" "', argument " "1"" of type '" "mem::ScopedCloneablePtr< six::sicd::DirectionParameters > *""'"); } - arg1 = reinterpret_cast< mem::ScopedCloneablePtr< six::sicd::Segment > * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_six__sicd__Segment, 0 | 0 ); + arg1 = reinterpret_cast< mem::ScopedCloneablePtr< six::sicd::DirectionParameters > * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_math__poly__TwoDT_double_t, 0 | 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScopedCloneableSegment_reset" "', argument " "2"" of type '" "six::sicd::Segment *""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScopedCloneableDirectionParameters_deltaKCOAPoly_set" "', argument " "2"" of type '" "six::Poly2D *""'"); } - arg2 = reinterpret_cast< six::sicd::Segment * >(argp2); + arg2 = reinterpret_cast< six::Poly2D * >(argp2); { try { - (arg1)->reset(arg2); + if (arg1) (*arg1)->deltaKCOAPoly = *arg2; } catch (const std::exception& e) { @@ -82870,23 +82835,24 @@ SWIGINTERN PyObject *_wrap_ScopedCloneableSegment_reset__SWIG_0(PyObject *SWIGUN } -SWIGINTERN PyObject *_wrap_ScopedCloneableSegment_reset__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ScopedCloneableDirectionParameters_deltaKCOAPoly_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mem::ScopedCloneablePtr< six::sicd::Segment > *arg1 = (mem::ScopedCloneablePtr< six::sicd::Segment > *) 0 ; + mem::ScopedCloneablePtr< six::sicd::DirectionParameters > *arg1 = (mem::ScopedCloneablePtr< six::sicd::DirectionParameters > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; + six::Poly2D *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:ScopedCloneableSegment_reset",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__Segment_t, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"O:ScopedCloneableDirectionParameters_deltaKCOAPoly_get",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__DirectionParameters_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedCloneableSegment_reset" "', argument " "1"" of type '" "mem::ScopedCloneablePtr< six::sicd::Segment > *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedCloneableDirectionParameters_deltaKCOAPoly_get" "', argument " "1"" of type '" "mem::ScopedCloneablePtr< six::sicd::DirectionParameters > *""'"); } - arg1 = reinterpret_cast< mem::ScopedCloneablePtr< six::sicd::Segment > * >(argp1); + arg1 = reinterpret_cast< mem::ScopedCloneablePtr< six::sicd::DirectionParameters > * >(argp1); { try { - (arg1)->reset(); + result = (six::Poly2D *)& ((*arg1)->deltaKCOAPoly); } catch (const std::exception& e) { @@ -82914,73 +82880,39 @@ SWIGINTERN PyObject *_wrap_ScopedCloneableSegment_reset__SWIG_1(PyObject *SWIGUN SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_math__poly__TwoDT_double_t, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_ScopedCloneableSegment_reset(PyObject *self, PyObject *args) { - int argc; - PyObject *argv[3]; - int ii; - - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? (int)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_mem__ScopedCloneablePtrT_six__sicd__Segment_t, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_ScopedCloneableSegment_reset__SWIG_1(self, args); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__Segment_t, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_six__sicd__Segment, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_ScopedCloneableSegment_reset__SWIG_0(self, args); - } - } - } - -fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ScopedCloneableSegment_reset'.\n" - " Possible C/C++ prototypes are:\n" - " mem::ScopedCloneablePtr< six::sicd::Segment >::reset(six::sicd::Segment *)\n" - " mem::ScopedCloneablePtr< six::sicd::Segment >::reset()\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_delete_ScopedCloneableSegment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ScopedCloneableDirectionParameters_weightType_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mem::ScopedCloneablePtr< six::sicd::Segment > *arg1 = (mem::ScopedCloneablePtr< six::sicd::Segment > *) 0 ; + mem::ScopedCloneablePtr< six::sicd::DirectionParameters > *arg1 = (mem::ScopedCloneablePtr< six::sicd::DirectionParameters > *) 0 ; + mem::ScopedCopyablePtr< six::sicd::WeightType > *arg2 = (mem::ScopedCopyablePtr< six::sicd::WeightType > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:delete_ScopedCloneableSegment",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__Segment_t, SWIG_POINTER_DISOWN | 0 ); + if (!PyArg_ParseTuple(args,(char *)"OO:ScopedCloneableDirectionParameters_weightType_set",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__DirectionParameters_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ScopedCloneableSegment" "', argument " "1"" of type '" "mem::ScopedCloneablePtr< six::sicd::Segment > *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedCloneableDirectionParameters_weightType_set" "', argument " "1"" of type '" "mem::ScopedCloneablePtr< six::sicd::DirectionParameters > *""'"); } - arg1 = reinterpret_cast< mem::ScopedCloneablePtr< six::sicd::Segment > * >(argp1); + arg1 = reinterpret_cast< mem::ScopedCloneablePtr< six::sicd::DirectionParameters > * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mem__ScopedCopyablePtrT_six__sicd__WeightType_t, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScopedCloneableDirectionParameters_weightType_set" "', argument " "2"" of type '" "mem::ScopedCopyablePtr< six::sicd::WeightType > *""'"); + } + arg2 = reinterpret_cast< mem::ScopedCopyablePtr< six::sicd::WeightType > * >(argp2); { try { - delete arg1; + if (arg1) (*arg1)->weightType = *arg2; } catch (const std::exception& e) { @@ -83015,24 +82947,24 @@ SWIGINTERN PyObject *_wrap_delete_ScopedCloneableSegment(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_ScopedCloneableSegment_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ScopedCloneableDirectionParameters_weightType_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mem::ScopedCloneablePtr< six::sicd::Segment > *arg1 = (mem::ScopedCloneablePtr< six::sicd::Segment > *) 0 ; + mem::ScopedCloneablePtr< six::sicd::DirectionParameters > *arg1 = (mem::ScopedCloneablePtr< six::sicd::DirectionParameters > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; - six::sicd::Segment *result = 0 ; + mem::ScopedCopyablePtr< six::sicd::WeightType > *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:ScopedCloneableSegment_clone",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__Segment_t, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"O:ScopedCloneableDirectionParameters_weightType_get",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__DirectionParameters_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedCloneableSegment_clone" "', argument " "1"" of type '" "mem::ScopedCloneablePtr< six::sicd::Segment > const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedCloneableDirectionParameters_weightType_get" "', argument " "1"" of type '" "mem::ScopedCloneablePtr< six::sicd::DirectionParameters > *""'"); } - arg1 = reinterpret_cast< mem::ScopedCloneablePtr< six::sicd::Segment > * >(argp1); + arg1 = reinterpret_cast< mem::ScopedCloneablePtr< six::sicd::DirectionParameters > * >(argp1); { try { - result = (six::sicd::Segment *)(*arg1)->clone(); + result = (mem::ScopedCopyablePtr< six::sicd::WeightType > *)& ((*arg1)->weightType); } catch (const std::exception& e) { @@ -83060,31 +82992,39 @@ SWIGINTERN PyObject *_wrap_ScopedCloneableSegment_clone(PyObject *SWIGUNUSEDPARM SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_six__sicd__Segment, 0 | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mem__ScopedCopyablePtrT_six__sicd__WeightType_t, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_ScopedCloneableSegment_getNumLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ScopedCloneableDirectionParameters_weights_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mem::ScopedCloneablePtr< six::sicd::Segment > *arg1 = (mem::ScopedCloneablePtr< six::sicd::Segment > *) 0 ; + mem::ScopedCloneablePtr< six::sicd::DirectionParameters > *arg1 = (mem::ScopedCloneablePtr< six::sicd::DirectionParameters > *) 0 ; + std::vector< double,std::allocator< double > > *arg2 = (std::vector< double,std::allocator< double > > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; PyObject * obj0 = 0 ; - int result; + PyObject * obj1 = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:ScopedCloneableSegment_getNumLines",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__Segment_t, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"OO:ScopedCloneableDirectionParameters_weights_set",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__DirectionParameters_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedCloneableSegment_getNumLines" "', argument " "1"" of type '" "mem::ScopedCloneablePtr< six::sicd::Segment > const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedCloneableDirectionParameters_weights_set" "', argument " "1"" of type '" "mem::ScopedCloneablePtr< six::sicd::DirectionParameters > *""'"); } - arg1 = reinterpret_cast< mem::ScopedCloneablePtr< six::sicd::Segment > * >(argp1); + arg1 = reinterpret_cast< mem::ScopedCloneablePtr< six::sicd::DirectionParameters > * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScopedCloneableDirectionParameters_weights_set" "', argument " "2"" of type '" "std::vector< double,std::allocator< double > > *""'"); + } + arg2 = reinterpret_cast< std::vector< double,std::allocator< double > > * >(argp2); { try { - result = (int)(*arg1)->getNumLines(); + if (arg1) (*arg1)->weights = *arg2; } catch (const std::exception& e) { @@ -83112,31 +83052,31 @@ SWIGINTERN PyObject *_wrap_ScopedCloneableSegment_getNumLines(PyObject *SWIGUNUS SWIG_fail; } } - resultobj = SWIG_From_int(static_cast< int >(result)); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_ScopedCloneableSegment_getNumSamples(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ScopedCloneableDirectionParameters_weights_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mem::ScopedCloneablePtr< six::sicd::Segment > *arg1 = (mem::ScopedCloneablePtr< six::sicd::Segment > *) 0 ; + mem::ScopedCloneablePtr< six::sicd::DirectionParameters > *arg1 = (mem::ScopedCloneablePtr< six::sicd::DirectionParameters > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; - int result; + std::vector< double,std::allocator< double > > *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:ScopedCloneableSegment_getNumSamples",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__Segment_t, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"O:ScopedCloneableDirectionParameters_weights_get",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__DirectionParameters_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedCloneableSegment_getNumSamples" "', argument " "1"" of type '" "mem::ScopedCloneablePtr< six::sicd::Segment > const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedCloneableDirectionParameters_weights_get" "', argument " "1"" of type '" "mem::ScopedCloneablePtr< six::sicd::DirectionParameters > *""'"); } - arg1 = reinterpret_cast< mem::ScopedCloneablePtr< six::sicd::Segment > * >(argp1); + arg1 = reinterpret_cast< mem::ScopedCloneablePtr< six::sicd::DirectionParameters > * >(argp1); { try { - result = (int)(*arg1)->getNumSamples(); + result = (std::vector< double,std::allocator< double > > *)& ((*arg1)->weights); } catch (const std::exception& e) { @@ -83164,39 +83104,38 @@ SWIGINTERN PyObject *_wrap_ScopedCloneableSegment_getNumSamples(PyObject *SWIGUN SWIG_fail; } } - resultobj = SWIG_From_int(static_cast< int >(result)); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_ScopedCloneableSegment_startLine_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *ScopedCloneableDirectionParameters_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__DirectionParameters_t, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *_wrap_new_ScopedCloneableAreaDirectionParameters__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mem::ScopedCloneablePtr< six::sicd::Segment > *arg1 = (mem::ScopedCloneablePtr< six::sicd::Segment > *) 0 ; - int arg2 ; + six::sicd::AreaDirectionParameters *arg1 = (six::sicd::AreaDirectionParameters *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - int val2 ; - int ecode2 = 0 ; PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + mem::ScopedCloneablePtr< six::sicd::AreaDirectionParameters > *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"OO:ScopedCloneableSegment_startLine_set",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__Segment_t, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"O:new_ScopedCloneableAreaDirectionParameters",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_six__sicd__AreaDirectionParameters, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedCloneableSegment_startLine_set" "', argument " "1"" of type '" "mem::ScopedCloneablePtr< six::sicd::Segment > *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ScopedCloneableAreaDirectionParameters" "', argument " "1"" of type '" "six::sicd::AreaDirectionParameters *""'"); } - arg1 = reinterpret_cast< mem::ScopedCloneablePtr< six::sicd::Segment > * >(argp1); - ecode2 = SWIG_AsVal_int(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScopedCloneableSegment_startLine_set" "', argument " "2"" of type '" "int""'"); - } - arg2 = static_cast< int >(val2); + arg1 = reinterpret_cast< six::sicd::AreaDirectionParameters * >(argp1); { try { - if (arg1) (*arg1)->startLine = arg2; + result = (mem::ScopedCloneablePtr< six::sicd::AreaDirectionParameters > *)new mem::ScopedCloneablePtr< six::sicd::AreaDirectionParameters >(arg1); } catch (const std::exception& e) { @@ -83224,31 +83163,22 @@ SWIGINTERN PyObject *_wrap_ScopedCloneableSegment_startLine_set(PyObject *SWIGUN SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__AreaDirectionParameters_t, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_ScopedCloneableSegment_startLine_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_ScopedCloneableAreaDirectionParameters__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mem::ScopedCloneablePtr< six::sicd::Segment > *arg1 = (mem::ScopedCloneablePtr< six::sicd::Segment > *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - int result; + mem::ScopedCloneablePtr< six::sicd::AreaDirectionParameters > *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:ScopedCloneableSegment_startLine_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__Segment_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedCloneableSegment_startLine_get" "', argument " "1"" of type '" "mem::ScopedCloneablePtr< six::sicd::Segment > *""'"); - } - arg1 = reinterpret_cast< mem::ScopedCloneablePtr< six::sicd::Segment > * >(argp1); + if (!PyArg_ParseTuple(args,(char *)":new_ScopedCloneableAreaDirectionParameters")) SWIG_fail; { try { - result = (int) ((*arg1)->startLine); + result = (mem::ScopedCloneablePtr< six::sicd::AreaDirectionParameters > *)new mem::ScopedCloneablePtr< six::sicd::AreaDirectionParameters >(); } catch (const std::exception& e) { @@ -83276,39 +83206,34 @@ SWIGINTERN PyObject *_wrap_ScopedCloneableSegment_startLine_get(PyObject *SWIGUN SWIG_fail; } } - resultobj = SWIG_From_int(static_cast< int >(result)); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__AreaDirectionParameters_t, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_ScopedCloneableSegment_startSample_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_ScopedCloneableAreaDirectionParameters__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mem::ScopedCloneablePtr< six::sicd::Segment > *arg1 = (mem::ScopedCloneablePtr< six::sicd::Segment > *) 0 ; - int arg2 ; + mem::ScopedCloneablePtr< six::sicd::AreaDirectionParameters > *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - int val2 ; - int ecode2 = 0 ; PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + mem::ScopedCloneablePtr< six::sicd::AreaDirectionParameters > *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"OO:ScopedCloneableSegment_startSample_set",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__Segment_t, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"O:new_ScopedCloneableAreaDirectionParameters",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__AreaDirectionParameters_t, 0 | 0); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedCloneableSegment_startSample_set" "', argument " "1"" of type '" "mem::ScopedCloneablePtr< six::sicd::Segment > *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ScopedCloneableAreaDirectionParameters" "', argument " "1"" of type '" "mem::ScopedCloneablePtr< six::sicd::AreaDirectionParameters > const &""'"); } - arg1 = reinterpret_cast< mem::ScopedCloneablePtr< six::sicd::Segment > * >(argp1); - ecode2 = SWIG_AsVal_int(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScopedCloneableSegment_startSample_set" "', argument " "2"" of type '" "int""'"); - } - arg2 = static_cast< int >(val2); + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ScopedCloneableAreaDirectionParameters" "', argument " "1"" of type '" "mem::ScopedCloneablePtr< six::sicd::AreaDirectionParameters > const &""'"); + } + arg1 = reinterpret_cast< mem::ScopedCloneablePtr< six::sicd::AreaDirectionParameters > * >(argp1); { try { - if (arg1) (*arg1)->startSample = arg2; + result = (mem::ScopedCloneablePtr< six::sicd::AreaDirectionParameters > *)new mem::ScopedCloneablePtr< six::sicd::AreaDirectionParameters >((mem::ScopedCloneablePtr< six::sicd::AreaDirectionParameters > const &)*arg1); } catch (const std::exception& e) { @@ -83336,31 +83261,72 @@ SWIGINTERN PyObject *_wrap_ScopedCloneableSegment_startSample_set(PyObject *SWIG SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__AreaDirectionParameters_t, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_ScopedCloneableSegment_startSample_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_ScopedCloneableAreaDirectionParameters(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[2]; + int ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = args ? (int)PyObject_Length(args) : 0; + for (ii = 0; (ii < 1) && (ii < argc); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); + } + if (argc == 0) { + return _wrap_new_ScopedCloneableAreaDirectionParameters__SWIG_1(self, args); + } + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_six__sicd__AreaDirectionParameters, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_ScopedCloneableAreaDirectionParameters__SWIG_0(self, args); + } + } + if (argc == 1) { + int _v; + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__AreaDirectionParameters_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_ScopedCloneableAreaDirectionParameters__SWIG_2(self, args); + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ScopedCloneableAreaDirectionParameters'.\n" + " Possible C/C++ prototypes are:\n" + " mem::ScopedCloneablePtr< six::sicd::AreaDirectionParameters >::ScopedCloneablePtr(six::sicd::AreaDirectionParameters *)\n" + " mem::ScopedCloneablePtr< six::sicd::AreaDirectionParameters >::ScopedCloneablePtr()\n" + " mem::ScopedCloneablePtr< six::sicd::AreaDirectionParameters >::ScopedCloneablePtr(mem::ScopedCloneablePtr< six::sicd::AreaDirectionParameters > const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_ScopedCloneableAreaDirectionParameters_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mem::ScopedCloneablePtr< six::sicd::Segment > *arg1 = (mem::ScopedCloneablePtr< six::sicd::Segment > *) 0 ; + mem::ScopedCloneablePtr< six::sicd::AreaDirectionParameters > *arg1 = (mem::ScopedCloneablePtr< six::sicd::AreaDirectionParameters > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; - int result; + six::sicd::AreaDirectionParameters *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:ScopedCloneableSegment_startSample_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__Segment_t, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"O:ScopedCloneableAreaDirectionParameters_get",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__AreaDirectionParameters_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedCloneableSegment_startSample_get" "', argument " "1"" of type '" "mem::ScopedCloneablePtr< six::sicd::Segment > *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedCloneableAreaDirectionParameters_get" "', argument " "1"" of type '" "mem::ScopedCloneablePtr< six::sicd::AreaDirectionParameters > const *""'"); } - arg1 = reinterpret_cast< mem::ScopedCloneablePtr< six::sicd::Segment > * >(argp1); + arg1 = reinterpret_cast< mem::ScopedCloneablePtr< six::sicd::AreaDirectionParameters > * >(argp1); { try { - result = (int) ((*arg1)->startSample); + result = (six::sicd::AreaDirectionParameters *)((mem::ScopedCloneablePtr< six::sicd::AreaDirectionParameters > const *)arg1)->get(); } catch (const std::exception& e) { @@ -83388,39 +83354,31 @@ SWIGINTERN PyObject *_wrap_ScopedCloneableSegment_startSample_get(PyObject *SWIG SWIG_fail; } } - resultobj = SWIG_From_int(static_cast< int >(result)); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_six__sicd__AreaDirectionParameters, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_ScopedCloneableSegment_endLine_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ScopedCloneableAreaDirectionParameters___ref__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mem::ScopedCloneablePtr< six::sicd::Segment > *arg1 = (mem::ScopedCloneablePtr< six::sicd::Segment > *) 0 ; - int arg2 ; + mem::ScopedCloneablePtr< six::sicd::AreaDirectionParameters > *arg1 = (mem::ScopedCloneablePtr< six::sicd::AreaDirectionParameters > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - int val2 ; - int ecode2 = 0 ; PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + six::sicd::AreaDirectionParameters *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"OO:ScopedCloneableSegment_endLine_set",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__Segment_t, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"O:ScopedCloneableAreaDirectionParameters___ref__",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__AreaDirectionParameters_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedCloneableSegment_endLine_set" "', argument " "1"" of type '" "mem::ScopedCloneablePtr< six::sicd::Segment > *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedCloneableAreaDirectionParameters___ref__" "', argument " "1"" of type '" "mem::ScopedCloneablePtr< six::sicd::AreaDirectionParameters > const *""'"); } - arg1 = reinterpret_cast< mem::ScopedCloneablePtr< six::sicd::Segment > * >(argp1); - ecode2 = SWIG_AsVal_int(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScopedCloneableSegment_endLine_set" "', argument " "2"" of type '" "int""'"); - } - arg2 = static_cast< int >(val2); + arg1 = reinterpret_cast< mem::ScopedCloneablePtr< six::sicd::AreaDirectionParameters > * >(argp1); { try { - if (arg1) (*arg1)->endLine = arg2; + result = (six::sicd::AreaDirectionParameters *) &((mem::ScopedCloneablePtr< six::sicd::AreaDirectionParameters > const *)arg1)->operator *(); } catch (const std::exception& e) { @@ -83448,31 +83406,31 @@ SWIGINTERN PyObject *_wrap_ScopedCloneableSegment_endLine_set(PyObject *SWIGUNUS SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_six__sicd__AreaDirectionParameters, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_ScopedCloneableSegment_endLine_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ScopedCloneableAreaDirectionParameters___deref__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mem::ScopedCloneablePtr< six::sicd::Segment > *arg1 = (mem::ScopedCloneablePtr< six::sicd::Segment > *) 0 ; + mem::ScopedCloneablePtr< six::sicd::AreaDirectionParameters > *arg1 = (mem::ScopedCloneablePtr< six::sicd::AreaDirectionParameters > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; - int result; + six::sicd::AreaDirectionParameters *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:ScopedCloneableSegment_endLine_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__Segment_t, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"O:ScopedCloneableAreaDirectionParameters___deref__",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__AreaDirectionParameters_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedCloneableSegment_endLine_get" "', argument " "1"" of type '" "mem::ScopedCloneablePtr< six::sicd::Segment > *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedCloneableAreaDirectionParameters___deref__" "', argument " "1"" of type '" "mem::ScopedCloneablePtr< six::sicd::AreaDirectionParameters > const *""'"); } - arg1 = reinterpret_cast< mem::ScopedCloneablePtr< six::sicd::Segment > * >(argp1); + arg1 = reinterpret_cast< mem::ScopedCloneablePtr< six::sicd::AreaDirectionParameters > * >(argp1); { try { - result = (int) ((*arg1)->endLine); + result = (six::sicd::AreaDirectionParameters *)((mem::ScopedCloneablePtr< six::sicd::AreaDirectionParameters > const *)arg1)->operator ->(); } catch (const std::exception& e) { @@ -83500,39 +83458,39 @@ SWIGINTERN PyObject *_wrap_ScopedCloneableSegment_endLine_get(PyObject *SWIGUNUS SWIG_fail; } } - resultobj = SWIG_From_int(static_cast< int >(result)); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_six__sicd__AreaDirectionParameters, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_ScopedCloneableSegment_endSample_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ScopedCloneableAreaDirectionParameters_reset__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mem::ScopedCloneablePtr< six::sicd::Segment > *arg1 = (mem::ScopedCloneablePtr< six::sicd::Segment > *) 0 ; - int arg2 ; + mem::ScopedCloneablePtr< six::sicd::AreaDirectionParameters > *arg1 = (mem::ScopedCloneablePtr< six::sicd::AreaDirectionParameters > *) 0 ; + six::sicd::AreaDirectionParameters *arg2 = (six::sicd::AreaDirectionParameters *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - int val2 ; - int ecode2 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; - if (!PyArg_ParseTuple(args,(char *)"OO:ScopedCloneableSegment_endSample_set",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__Segment_t, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"OO:ScopedCloneableAreaDirectionParameters_reset",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__AreaDirectionParameters_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedCloneableSegment_endSample_set" "', argument " "1"" of type '" "mem::ScopedCloneablePtr< six::sicd::Segment > *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedCloneableAreaDirectionParameters_reset" "', argument " "1"" of type '" "mem::ScopedCloneablePtr< six::sicd::AreaDirectionParameters > *""'"); } - arg1 = reinterpret_cast< mem::ScopedCloneablePtr< six::sicd::Segment > * >(argp1); - ecode2 = SWIG_AsVal_int(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScopedCloneableSegment_endSample_set" "', argument " "2"" of type '" "int""'"); - } - arg2 = static_cast< int >(val2); + arg1 = reinterpret_cast< mem::ScopedCloneablePtr< six::sicd::AreaDirectionParameters > * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_six__sicd__AreaDirectionParameters, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScopedCloneableAreaDirectionParameters_reset" "', argument " "2"" of type '" "six::sicd::AreaDirectionParameters *""'"); + } + arg2 = reinterpret_cast< six::sicd::AreaDirectionParameters * >(argp2); { try { - if (arg1) (*arg1)->endSample = arg2; + (arg1)->reset(arg2); } catch (const std::exception& e) { @@ -83567,24 +83525,23 @@ SWIGINTERN PyObject *_wrap_ScopedCloneableSegment_endSample_set(PyObject *SWIGUN } -SWIGINTERN PyObject *_wrap_ScopedCloneableSegment_endSample_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ScopedCloneableAreaDirectionParameters_reset__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mem::ScopedCloneablePtr< six::sicd::Segment > *arg1 = (mem::ScopedCloneablePtr< six::sicd::Segment > *) 0 ; + mem::ScopedCloneablePtr< six::sicd::AreaDirectionParameters > *arg1 = (mem::ScopedCloneablePtr< six::sicd::AreaDirectionParameters > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; - int result; - if (!PyArg_ParseTuple(args,(char *)"O:ScopedCloneableSegment_endSample_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__Segment_t, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"O:ScopedCloneableAreaDirectionParameters_reset",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__AreaDirectionParameters_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedCloneableSegment_endSample_get" "', argument " "1"" of type '" "mem::ScopedCloneablePtr< six::sicd::Segment > *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedCloneableAreaDirectionParameters_reset" "', argument " "1"" of type '" "mem::ScopedCloneablePtr< six::sicd::AreaDirectionParameters > *""'"); } - arg1 = reinterpret_cast< mem::ScopedCloneablePtr< six::sicd::Segment > * >(argp1); + arg1 = reinterpret_cast< mem::ScopedCloneablePtr< six::sicd::AreaDirectionParameters > * >(argp1); { try { - result = (int) ((*arg1)->endSample); + (arg1)->reset(); } catch (const std::exception& e) { @@ -83612,44 +83569,73 @@ SWIGINTERN PyObject *_wrap_ScopedCloneableSegment_endSample_get(PyObject *SWIGUN SWIG_fail; } } - resultobj = SWIG_From_int(static_cast< int >(result)); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_ScopedCloneableSegment_identifier_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ScopedCloneableAreaDirectionParameters_reset(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + int ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = args ? (int)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_mem__ScopedCloneablePtrT_six__sicd__AreaDirectionParameters_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_ScopedCloneableAreaDirectionParameters_reset__SWIG_1(self, args); + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__AreaDirectionParameters_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_six__sicd__AreaDirectionParameters, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_ScopedCloneableAreaDirectionParameters_reset__SWIG_0(self, args); + } + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ScopedCloneableAreaDirectionParameters_reset'.\n" + " Possible C/C++ prototypes are:\n" + " mem::ScopedCloneablePtr< six::sicd::AreaDirectionParameters >::reset(six::sicd::AreaDirectionParameters *)\n" + " mem::ScopedCloneablePtr< six::sicd::AreaDirectionParameters >::reset()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_delete_ScopedCloneableAreaDirectionParameters(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mem::ScopedCloneablePtr< six::sicd::Segment > *arg1 = (mem::ScopedCloneablePtr< six::sicd::Segment > *) 0 ; - std::string *arg2 = 0 ; + mem::ScopedCloneablePtr< six::sicd::AreaDirectionParameters > *arg1 = (mem::ScopedCloneablePtr< six::sicd::AreaDirectionParameters > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - int res2 = SWIG_OLDOBJ ; PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - if (!PyArg_ParseTuple(args,(char *)"OO:ScopedCloneableSegment_identifier_set",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__Segment_t, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"O:delete_ScopedCloneableAreaDirectionParameters",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__AreaDirectionParameters_t, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedCloneableSegment_identifier_set" "', argument " "1"" of type '" "mem::ScopedCloneablePtr< six::sicd::Segment > *""'"); - } - arg1 = reinterpret_cast< mem::ScopedCloneablePtr< six::sicd::Segment > * >(argp1); - { - std::string *ptr = (std::string *)0; - res2 = SWIG_AsPtr_std_string(obj1, &ptr); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScopedCloneableSegment_identifier_set" "', argument " "2"" of type '" "std::string const &""'"); - } - if (!ptr) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ScopedCloneableSegment_identifier_set" "', argument " "2"" of type '" "std::string const &""'"); - } - arg2 = ptr; + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ScopedCloneableAreaDirectionParameters" "', argument " "1"" of type '" "mem::ScopedCloneablePtr< six::sicd::AreaDirectionParameters > *""'"); } + arg1 = reinterpret_cast< mem::ScopedCloneablePtr< six::sicd::AreaDirectionParameters > * >(argp1); { try { - if (arg1) (*arg1)->identifier = *arg2; + delete arg1; } catch (const std::exception& e) { @@ -83678,32 +83664,30 @@ SWIGINTERN PyObject *_wrap_ScopedCloneableSegment_identifier_set(PyObject *SWIGU } } resultobj = SWIG_Py_Void(); - if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail: - if (SWIG_IsNewObj(res2)) delete arg2; return NULL; } -SWIGINTERN PyObject *_wrap_ScopedCloneableSegment_identifier_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ScopedCloneableAreaDirectionParameters_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mem::ScopedCloneablePtr< six::sicd::Segment > *arg1 = (mem::ScopedCloneablePtr< six::sicd::Segment > *) 0 ; + mem::ScopedCloneablePtr< six::sicd::AreaDirectionParameters > *arg1 = (mem::ScopedCloneablePtr< six::sicd::AreaDirectionParameters > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; - std::string *result = 0 ; + six::sicd::AreaDirectionParameters *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:ScopedCloneableSegment_identifier_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__Segment_t, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"O:ScopedCloneableAreaDirectionParameters_clone",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__AreaDirectionParameters_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedCloneableSegment_identifier_get" "', argument " "1"" of type '" "mem::ScopedCloneablePtr< six::sicd::Segment > *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedCloneableAreaDirectionParameters_clone" "', argument " "1"" of type '" "mem::ScopedCloneablePtr< six::sicd::AreaDirectionParameters > const *""'"); } - arg1 = reinterpret_cast< mem::ScopedCloneablePtr< six::sicd::Segment > * >(argp1); + arg1 = reinterpret_cast< mem::ScopedCloneablePtr< six::sicd::AreaDirectionParameters > * >(argp1); { try { - result = (std::string *) & ((*arg1)->identifier); + result = (six::sicd::AreaDirectionParameters *)(*arg1)->clone(); } catch (const std::exception& e) { @@ -83731,38 +83715,39 @@ SWIGINTERN PyObject *_wrap_ScopedCloneableSegment_identifier_get(PyObject *SWIGU SWIG_fail; } } - resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_six__sicd__AreaDirectionParameters, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *ScopedCloneableSegment_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__Segment_t, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *_wrap_new_ScopedCloneableTxStep__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ScopedCloneableAreaDirectionParameters_unitVector_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - six::sicd::TxStep *arg1 = (six::sicd::TxStep *) 0 ; + mem::ScopedCloneablePtr< six::sicd::AreaDirectionParameters > *arg1 = (mem::ScopedCloneablePtr< six::sicd::AreaDirectionParameters > *) 0 ; + six::Vector3 *arg2 = (six::Vector3 *) 0 ; void *argp1 = 0 ; int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; PyObject * obj0 = 0 ; - mem::ScopedCloneablePtr< six::sicd::TxStep > *result = 0 ; + PyObject * obj1 = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:new_ScopedCloneableTxStep",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_six__sicd__TxStep, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"OO:ScopedCloneableAreaDirectionParameters_unitVector_set",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__AreaDirectionParameters_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ScopedCloneableTxStep" "', argument " "1"" of type '" "six::sicd::TxStep *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedCloneableAreaDirectionParameters_unitVector_set" "', argument " "1"" of type '" "mem::ScopedCloneablePtr< six::sicd::AreaDirectionParameters > *""'"); } - arg1 = reinterpret_cast< six::sicd::TxStep * >(argp1); + arg1 = reinterpret_cast< mem::ScopedCloneablePtr< six::sicd::AreaDirectionParameters > * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_math__linear__VectorNT_3_double_t, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScopedCloneableAreaDirectionParameters_unitVector_set" "', argument " "2"" of type '" "six::Vector3 *""'"); + } + arg2 = reinterpret_cast< six::Vector3 * >(argp2); { try { - result = (mem::ScopedCloneablePtr< six::sicd::TxStep > *)new mem::ScopedCloneablePtr< six::sicd::TxStep >(arg1); + if (arg1) (*arg1)->unitVector = *arg2; } catch (const std::exception& e) { @@ -83790,22 +83775,31 @@ SWIGINTERN PyObject *_wrap_new_ScopedCloneableTxStep__SWIG_0(PyObject *SWIGUNUSE SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__TxStep_t, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_ScopedCloneableTxStep__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ScopedCloneableAreaDirectionParameters_unitVector_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mem::ScopedCloneablePtr< six::sicd::TxStep > *result = 0 ; + mem::ScopedCloneablePtr< six::sicd::AreaDirectionParameters > *arg1 = (mem::ScopedCloneablePtr< six::sicd::AreaDirectionParameters > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + six::Vector3 *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)":new_ScopedCloneableTxStep")) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"O:ScopedCloneableAreaDirectionParameters_unitVector_get",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__AreaDirectionParameters_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedCloneableAreaDirectionParameters_unitVector_get" "', argument " "1"" of type '" "mem::ScopedCloneablePtr< six::sicd::AreaDirectionParameters > *""'"); + } + arg1 = reinterpret_cast< mem::ScopedCloneablePtr< six::sicd::AreaDirectionParameters > * >(argp1); { try { - result = (mem::ScopedCloneablePtr< six::sicd::TxStep > *)new mem::ScopedCloneablePtr< six::sicd::TxStep >(); + result = (six::Vector3 *)& ((*arg1)->unitVector); } catch (const std::exception& e) { @@ -83833,34 +83827,39 @@ SWIGINTERN PyObject *_wrap_new_ScopedCloneableTxStep__SWIG_1(PyObject *SWIGUNUSE SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__TxStep_t, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_math__linear__VectorNT_3_double_t, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_ScopedCloneableTxStep__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ScopedCloneableAreaDirectionParameters_spacing_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mem::ScopedCloneablePtr< six::sicd::TxStep > *arg1 = 0 ; + mem::ScopedCloneablePtr< six::sicd::AreaDirectionParameters > *arg1 = (mem::ScopedCloneablePtr< six::sicd::AreaDirectionParameters > *) 0 ; + double arg2 ; void *argp1 = 0 ; int res1 = 0 ; + double val2 ; + int ecode2 = 0 ; PyObject * obj0 = 0 ; - mem::ScopedCloneablePtr< six::sicd::TxStep > *result = 0 ; + PyObject * obj1 = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:new_ScopedCloneableTxStep",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__TxStep_t, 0 | 0); + if (!PyArg_ParseTuple(args,(char *)"OO:ScopedCloneableAreaDirectionParameters_spacing_set",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__AreaDirectionParameters_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ScopedCloneableTxStep" "', argument " "1"" of type '" "mem::ScopedCloneablePtr< six::sicd::TxStep > const &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedCloneableAreaDirectionParameters_spacing_set" "', argument " "1"" of type '" "mem::ScopedCloneablePtr< six::sicd::AreaDirectionParameters > *""'"); } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ScopedCloneableTxStep" "', argument " "1"" of type '" "mem::ScopedCloneablePtr< six::sicd::TxStep > const &""'"); - } - arg1 = reinterpret_cast< mem::ScopedCloneablePtr< six::sicd::TxStep > * >(argp1); + arg1 = reinterpret_cast< mem::ScopedCloneablePtr< six::sicd::AreaDirectionParameters > * >(argp1); + ecode2 = SWIG_AsVal_double(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScopedCloneableAreaDirectionParameters_spacing_set" "', argument " "2"" of type '" "double""'"); + } + arg2 = static_cast< double >(val2); { try { - result = (mem::ScopedCloneablePtr< six::sicd::TxStep > *)new mem::ScopedCloneablePtr< six::sicd::TxStep >((mem::ScopedCloneablePtr< six::sicd::TxStep > const &)*arg1); + if (arg1) (*arg1)->spacing = arg2; } catch (const std::exception& e) { @@ -83888,72 +83887,31 @@ SWIGINTERN PyObject *_wrap_new_ScopedCloneableTxStep__SWIG_2(PyObject *SWIGUNUSE SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__TxStep_t, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_ScopedCloneableTxStep(PyObject *self, PyObject *args) { - int argc; - PyObject *argv[2]; - int ii; - - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? (int)PyObject_Length(args) : 0; - for (ii = 0; (ii < 1) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } - if (argc == 0) { - return _wrap_new_ScopedCloneableTxStep__SWIG_1(self, args); - } - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_six__sicd__TxStep, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_ScopedCloneableTxStep__SWIG_0(self, args); - } - } - if (argc == 1) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__TxStep_t, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_ScopedCloneableTxStep__SWIG_2(self, args); - } - } - -fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ScopedCloneableTxStep'.\n" - " Possible C/C++ prototypes are:\n" - " mem::ScopedCloneablePtr< six::sicd::TxStep >::ScopedCloneablePtr(six::sicd::TxStep *)\n" - " mem::ScopedCloneablePtr< six::sicd::TxStep >::ScopedCloneablePtr()\n" - " mem::ScopedCloneablePtr< six::sicd::TxStep >::ScopedCloneablePtr(mem::ScopedCloneablePtr< six::sicd::TxStep > const &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_ScopedCloneableTxStep_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ScopedCloneableAreaDirectionParameters_spacing_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mem::ScopedCloneablePtr< six::sicd::TxStep > *arg1 = (mem::ScopedCloneablePtr< six::sicd::TxStep > *) 0 ; + mem::ScopedCloneablePtr< six::sicd::AreaDirectionParameters > *arg1 = (mem::ScopedCloneablePtr< six::sicd::AreaDirectionParameters > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; - six::sicd::TxStep *result = 0 ; + double result; - if (!PyArg_ParseTuple(args,(char *)"O:ScopedCloneableTxStep_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__TxStep_t, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"O:ScopedCloneableAreaDirectionParameters_spacing_get",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__AreaDirectionParameters_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedCloneableTxStep_get" "', argument " "1"" of type '" "mem::ScopedCloneablePtr< six::sicd::TxStep > const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedCloneableAreaDirectionParameters_spacing_get" "', argument " "1"" of type '" "mem::ScopedCloneablePtr< six::sicd::AreaDirectionParameters > *""'"); } - arg1 = reinterpret_cast< mem::ScopedCloneablePtr< six::sicd::TxStep > * >(argp1); + arg1 = reinterpret_cast< mem::ScopedCloneablePtr< six::sicd::AreaDirectionParameters > * >(argp1); { try { - result = (six::sicd::TxStep *)((mem::ScopedCloneablePtr< six::sicd::TxStep > const *)arg1)->get(); + result = (double) ((*arg1)->spacing); } catch (const std::exception& e) { @@ -83981,31 +83939,39 @@ SWIGINTERN PyObject *_wrap_ScopedCloneableTxStep_get(PyObject *SWIGUNUSEDPARM(se SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_six__sicd__TxStep, 0 | 0 ); + resultobj = SWIG_From_double(static_cast< double >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_ScopedCloneableTxStep___ref__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ScopedCloneableAreaDirectionParameters_elements_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mem::ScopedCloneablePtr< six::sicd::TxStep > *arg1 = (mem::ScopedCloneablePtr< six::sicd::TxStep > *) 0 ; + mem::ScopedCloneablePtr< six::sicd::AreaDirectionParameters > *arg1 = (mem::ScopedCloneablePtr< six::sicd::AreaDirectionParameters > *) 0 ; + size_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; + size_t val2 ; + int ecode2 = 0 ; PyObject * obj0 = 0 ; - six::sicd::TxStep *result = 0 ; + PyObject * obj1 = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:ScopedCloneableTxStep___ref__",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__TxStep_t, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"OO:ScopedCloneableAreaDirectionParameters_elements_set",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__AreaDirectionParameters_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedCloneableTxStep___ref__" "', argument " "1"" of type '" "mem::ScopedCloneablePtr< six::sicd::TxStep > const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedCloneableAreaDirectionParameters_elements_set" "', argument " "1"" of type '" "mem::ScopedCloneablePtr< six::sicd::AreaDirectionParameters > *""'"); } - arg1 = reinterpret_cast< mem::ScopedCloneablePtr< six::sicd::TxStep > * >(argp1); + arg1 = reinterpret_cast< mem::ScopedCloneablePtr< six::sicd::AreaDirectionParameters > * >(argp1); + ecode2 = SWIG_AsVal_size_t(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScopedCloneableAreaDirectionParameters_elements_set" "', argument " "2"" of type '" "size_t""'"); + } + arg2 = static_cast< size_t >(val2); { try { - result = (six::sicd::TxStep *) &((mem::ScopedCloneablePtr< six::sicd::TxStep > const *)arg1)->operator *(); + if (arg1) (*arg1)->elements = arg2; } catch (const std::exception& e) { @@ -84033,31 +83999,1907 @@ SWIGINTERN PyObject *_wrap_ScopedCloneableTxStep___ref__(PyObject *SWIGUNUSEDPAR SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_six__sicd__TxStep, 0 | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_ScopedCloneableTxStep___deref__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ScopedCloneableAreaDirectionParameters_elements_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mem::ScopedCloneablePtr< six::sicd::TxStep > *arg1 = (mem::ScopedCloneablePtr< six::sicd::TxStep > *) 0 ; + mem::ScopedCloneablePtr< six::sicd::AreaDirectionParameters > *arg1 = (mem::ScopedCloneablePtr< six::sicd::AreaDirectionParameters > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; - six::sicd::TxStep *result = 0 ; + size_t result; - if (!PyArg_ParseTuple(args,(char *)"O:ScopedCloneableTxStep___deref__",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__TxStep_t, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"O:ScopedCloneableAreaDirectionParameters_elements_get",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__AreaDirectionParameters_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedCloneableTxStep___deref__" "', argument " "1"" of type '" "mem::ScopedCloneablePtr< six::sicd::TxStep > const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedCloneableAreaDirectionParameters_elements_get" "', argument " "1"" of type '" "mem::ScopedCloneablePtr< six::sicd::AreaDirectionParameters > *""'"); } - arg1 = reinterpret_cast< mem::ScopedCloneablePtr< six::sicd::TxStep > * >(argp1); + arg1 = reinterpret_cast< mem::ScopedCloneablePtr< six::sicd::AreaDirectionParameters > * >(argp1); { try { - result = (six::sicd::TxStep *)((mem::ScopedCloneablePtr< six::sicd::TxStep > const *)arg1)->operator ->(); + result = ((*arg1)->elements); + } + catch (const std::exception& e) + { + if (!PyErr_Occurred()) + { + PyErr_SetString(PyExc_RuntimeError, e.what()); + } + } + catch (const except::Exception& e) + { + if (!PyErr_Occurred()) + { + PyErr_SetString(PyExc_RuntimeError, e.getMessage().c_str()); + } + } + catch (...) + { + if (!PyErr_Occurred()) + { + PyErr_SetString(PyExc_RuntimeError, "Unknown error"); + } + } + if (PyErr_Occurred()) + { + SWIG_fail; + } + } + resultobj = SWIG_From_size_t(static_cast< size_t >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ScopedCloneableAreaDirectionParameters_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mem::ScopedCloneablePtr< six::sicd::AreaDirectionParameters > *arg1 = (mem::ScopedCloneablePtr< six::sicd::AreaDirectionParameters > *) 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:ScopedCloneableAreaDirectionParameters_first_set",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__AreaDirectionParameters_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedCloneableAreaDirectionParameters_first_set" "', argument " "1"" of type '" "mem::ScopedCloneablePtr< six::sicd::AreaDirectionParameters > *""'"); + } + arg1 = reinterpret_cast< mem::ScopedCloneablePtr< six::sicd::AreaDirectionParameters > * >(argp1); + ecode2 = SWIG_AsVal_size_t(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScopedCloneableAreaDirectionParameters_first_set" "', argument " "2"" of type '" "size_t""'"); + } + arg2 = static_cast< size_t >(val2); + { + try + { + if (arg1) (*arg1)->first = arg2; + } + catch (const std::exception& e) + { + if (!PyErr_Occurred()) + { + PyErr_SetString(PyExc_RuntimeError, e.what()); + } + } + catch (const except::Exception& e) + { + if (!PyErr_Occurred()) + { + PyErr_SetString(PyExc_RuntimeError, e.getMessage().c_str()); + } + } + catch (...) + { + if (!PyErr_Occurred()) + { + PyErr_SetString(PyExc_RuntimeError, "Unknown error"); + } + } + if (PyErr_Occurred()) + { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ScopedCloneableAreaDirectionParameters_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mem::ScopedCloneablePtr< six::sicd::AreaDirectionParameters > *arg1 = (mem::ScopedCloneablePtr< six::sicd::AreaDirectionParameters > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + size_t result; + + if (!PyArg_ParseTuple(args,(char *)"O:ScopedCloneableAreaDirectionParameters_first_get",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__AreaDirectionParameters_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedCloneableAreaDirectionParameters_first_get" "', argument " "1"" of type '" "mem::ScopedCloneablePtr< six::sicd::AreaDirectionParameters > *""'"); + } + arg1 = reinterpret_cast< mem::ScopedCloneablePtr< six::sicd::AreaDirectionParameters > * >(argp1); + { + try + { + result = ((*arg1)->first); + } + catch (const std::exception& e) + { + if (!PyErr_Occurred()) + { + PyErr_SetString(PyExc_RuntimeError, e.what()); + } + } + catch (const except::Exception& e) + { + if (!PyErr_Occurred()) + { + PyErr_SetString(PyExc_RuntimeError, e.getMessage().c_str()); + } + } + catch (...) + { + if (!PyErr_Occurred()) + { + PyErr_SetString(PyExc_RuntimeError, "Unknown error"); + } + } + if (PyErr_Occurred()) + { + SWIG_fail; + } + } + resultobj = SWIG_From_size_t(static_cast< size_t >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ScopedCloneableAreaDirectionParameters___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mem::ScopedCloneablePtr< six::sicd::AreaDirectionParameters > *arg1 = (mem::ScopedCloneablePtr< six::sicd::AreaDirectionParameters > *) 0 ; + six::sicd::AreaDirectionParameters *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:ScopedCloneableAreaDirectionParameters___eq__",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__AreaDirectionParameters_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedCloneableAreaDirectionParameters___eq__" "', argument " "1"" of type '" "mem::ScopedCloneablePtr< six::sicd::AreaDirectionParameters > const *""'"); + } + arg1 = reinterpret_cast< mem::ScopedCloneablePtr< six::sicd::AreaDirectionParameters > * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_six__sicd__AreaDirectionParameters, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScopedCloneableAreaDirectionParameters___eq__" "', argument " "2"" of type '" "six::sicd::AreaDirectionParameters const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ScopedCloneableAreaDirectionParameters___eq__" "', argument " "2"" of type '" "six::sicd::AreaDirectionParameters const &""'"); + } + arg2 = reinterpret_cast< six::sicd::AreaDirectionParameters * >(argp2); + { + try + { + result = (bool)(*arg1)->operator ==((six::sicd::AreaDirectionParameters const &)*arg2); + } + catch (const std::exception& e) + { + if (!PyErr_Occurred()) + { + PyErr_SetString(PyExc_RuntimeError, e.what()); + } + } + catch (const except::Exception& e) + { + if (!PyErr_Occurred()) + { + PyErr_SetString(PyExc_RuntimeError, e.getMessage().c_str()); + } + } + catch (...) + { + if (!PyErr_Occurred()) + { + PyErr_SetString(PyExc_RuntimeError, "Unknown error"); + } + } + if (PyErr_Occurred()) + { + SWIG_fail; + } + } + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ScopedCloneableAreaDirectionParameters___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mem::ScopedCloneablePtr< six::sicd::AreaDirectionParameters > *arg1 = (mem::ScopedCloneablePtr< six::sicd::AreaDirectionParameters > *) 0 ; + six::sicd::AreaDirectionParameters *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:ScopedCloneableAreaDirectionParameters___ne__",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__AreaDirectionParameters_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedCloneableAreaDirectionParameters___ne__" "', argument " "1"" of type '" "mem::ScopedCloneablePtr< six::sicd::AreaDirectionParameters > const *""'"); + } + arg1 = reinterpret_cast< mem::ScopedCloneablePtr< six::sicd::AreaDirectionParameters > * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_six__sicd__AreaDirectionParameters, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScopedCloneableAreaDirectionParameters___ne__" "', argument " "2"" of type '" "six::sicd::AreaDirectionParameters const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ScopedCloneableAreaDirectionParameters___ne__" "', argument " "2"" of type '" "six::sicd::AreaDirectionParameters const &""'"); + } + arg2 = reinterpret_cast< six::sicd::AreaDirectionParameters * >(argp2); + { + try + { + result = (bool)(*arg1)->operator !=((six::sicd::AreaDirectionParameters const &)*arg2); + } + catch (const std::exception& e) + { + if (!PyErr_Occurred()) + { + PyErr_SetString(PyExc_RuntimeError, e.what()); + } + } + catch (const except::Exception& e) + { + if (!PyErr_Occurred()) + { + PyErr_SetString(PyExc_RuntimeError, e.getMessage().c_str()); + } + } + catch (...) + { + if (!PyErr_Occurred()) + { + PyErr_SetString(PyExc_RuntimeError, "Unknown error"); + } + } + if (PyErr_Occurred()) + { + SWIG_fail; + } + } + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *ScopedCloneableAreaDirectionParameters_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__AreaDirectionParameters_t, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *_wrap_new_ScopedCloneableSegment__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + six::sicd::Segment *arg1 = (six::sicd::Segment *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + mem::ScopedCloneablePtr< six::sicd::Segment > *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:new_ScopedCloneableSegment",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_six__sicd__Segment, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ScopedCloneableSegment" "', argument " "1"" of type '" "six::sicd::Segment *""'"); + } + arg1 = reinterpret_cast< six::sicd::Segment * >(argp1); + { + try + { + result = (mem::ScopedCloneablePtr< six::sicd::Segment > *)new mem::ScopedCloneablePtr< six::sicd::Segment >(arg1); + } + catch (const std::exception& e) + { + if (!PyErr_Occurred()) + { + PyErr_SetString(PyExc_RuntimeError, e.what()); + } + } + catch (const except::Exception& e) + { + if (!PyErr_Occurred()) + { + PyErr_SetString(PyExc_RuntimeError, e.getMessage().c_str()); + } + } + catch (...) + { + if (!PyErr_Occurred()) + { + PyErr_SetString(PyExc_RuntimeError, "Unknown error"); + } + } + if (PyErr_Occurred()) + { + SWIG_fail; + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__Segment_t, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_ScopedCloneableSegment__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mem::ScopedCloneablePtr< six::sicd::Segment > *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)":new_ScopedCloneableSegment")) SWIG_fail; + { + try + { + result = (mem::ScopedCloneablePtr< six::sicd::Segment > *)new mem::ScopedCloneablePtr< six::sicd::Segment >(); + } + catch (const std::exception& e) + { + if (!PyErr_Occurred()) + { + PyErr_SetString(PyExc_RuntimeError, e.what()); + } + } + catch (const except::Exception& e) + { + if (!PyErr_Occurred()) + { + PyErr_SetString(PyExc_RuntimeError, e.getMessage().c_str()); + } + } + catch (...) + { + if (!PyErr_Occurred()) + { + PyErr_SetString(PyExc_RuntimeError, "Unknown error"); + } + } + if (PyErr_Occurred()) + { + SWIG_fail; + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__Segment_t, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_ScopedCloneableSegment__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mem::ScopedCloneablePtr< six::sicd::Segment > *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + mem::ScopedCloneablePtr< six::sicd::Segment > *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:new_ScopedCloneableSegment",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__Segment_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ScopedCloneableSegment" "', argument " "1"" of type '" "mem::ScopedCloneablePtr< six::sicd::Segment > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ScopedCloneableSegment" "', argument " "1"" of type '" "mem::ScopedCloneablePtr< six::sicd::Segment > const &""'"); + } + arg1 = reinterpret_cast< mem::ScopedCloneablePtr< six::sicd::Segment > * >(argp1); + { + try + { + result = (mem::ScopedCloneablePtr< six::sicd::Segment > *)new mem::ScopedCloneablePtr< six::sicd::Segment >((mem::ScopedCloneablePtr< six::sicd::Segment > const &)*arg1); + } + catch (const std::exception& e) + { + if (!PyErr_Occurred()) + { + PyErr_SetString(PyExc_RuntimeError, e.what()); + } + } + catch (const except::Exception& e) + { + if (!PyErr_Occurred()) + { + PyErr_SetString(PyExc_RuntimeError, e.getMessage().c_str()); + } + } + catch (...) + { + if (!PyErr_Occurred()) + { + PyErr_SetString(PyExc_RuntimeError, "Unknown error"); + } + } + if (PyErr_Occurred()) + { + SWIG_fail; + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__Segment_t, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_ScopedCloneableSegment(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[2]; + int ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = args ? (int)PyObject_Length(args) : 0; + for (ii = 0; (ii < 1) && (ii < argc); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); + } + if (argc == 0) { + return _wrap_new_ScopedCloneableSegment__SWIG_1(self, args); + } + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_six__sicd__Segment, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_ScopedCloneableSegment__SWIG_0(self, args); + } + } + if (argc == 1) { + int _v; + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__Segment_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_ScopedCloneableSegment__SWIG_2(self, args); + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ScopedCloneableSegment'.\n" + " Possible C/C++ prototypes are:\n" + " mem::ScopedCloneablePtr< six::sicd::Segment >::ScopedCloneablePtr(six::sicd::Segment *)\n" + " mem::ScopedCloneablePtr< six::sicd::Segment >::ScopedCloneablePtr()\n" + " mem::ScopedCloneablePtr< six::sicd::Segment >::ScopedCloneablePtr(mem::ScopedCloneablePtr< six::sicd::Segment > const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_ScopedCloneableSegment_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mem::ScopedCloneablePtr< six::sicd::Segment > *arg1 = (mem::ScopedCloneablePtr< six::sicd::Segment > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + six::sicd::Segment *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:ScopedCloneableSegment_get",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__Segment_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedCloneableSegment_get" "', argument " "1"" of type '" "mem::ScopedCloneablePtr< six::sicd::Segment > const *""'"); + } + arg1 = reinterpret_cast< mem::ScopedCloneablePtr< six::sicd::Segment > * >(argp1); + { + try + { + result = (six::sicd::Segment *)((mem::ScopedCloneablePtr< six::sicd::Segment > const *)arg1)->get(); + } + catch (const std::exception& e) + { + if (!PyErr_Occurred()) + { + PyErr_SetString(PyExc_RuntimeError, e.what()); + } + } + catch (const except::Exception& e) + { + if (!PyErr_Occurred()) + { + PyErr_SetString(PyExc_RuntimeError, e.getMessage().c_str()); + } + } + catch (...) + { + if (!PyErr_Occurred()) + { + PyErr_SetString(PyExc_RuntimeError, "Unknown error"); + } + } + if (PyErr_Occurred()) + { + SWIG_fail; + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_six__sicd__Segment, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ScopedCloneableSegment___ref__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mem::ScopedCloneablePtr< six::sicd::Segment > *arg1 = (mem::ScopedCloneablePtr< six::sicd::Segment > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + six::sicd::Segment *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:ScopedCloneableSegment___ref__",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__Segment_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedCloneableSegment___ref__" "', argument " "1"" of type '" "mem::ScopedCloneablePtr< six::sicd::Segment > const *""'"); + } + arg1 = reinterpret_cast< mem::ScopedCloneablePtr< six::sicd::Segment > * >(argp1); + { + try + { + result = (six::sicd::Segment *) &((mem::ScopedCloneablePtr< six::sicd::Segment > const *)arg1)->operator *(); + } + catch (const std::exception& e) + { + if (!PyErr_Occurred()) + { + PyErr_SetString(PyExc_RuntimeError, e.what()); + } + } + catch (const except::Exception& e) + { + if (!PyErr_Occurred()) + { + PyErr_SetString(PyExc_RuntimeError, e.getMessage().c_str()); + } + } + catch (...) + { + if (!PyErr_Occurred()) + { + PyErr_SetString(PyExc_RuntimeError, "Unknown error"); + } + } + if (PyErr_Occurred()) + { + SWIG_fail; + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_six__sicd__Segment, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ScopedCloneableSegment___deref__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mem::ScopedCloneablePtr< six::sicd::Segment > *arg1 = (mem::ScopedCloneablePtr< six::sicd::Segment > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + six::sicd::Segment *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:ScopedCloneableSegment___deref__",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__Segment_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedCloneableSegment___deref__" "', argument " "1"" of type '" "mem::ScopedCloneablePtr< six::sicd::Segment > const *""'"); + } + arg1 = reinterpret_cast< mem::ScopedCloneablePtr< six::sicd::Segment > * >(argp1); + { + try + { + result = (six::sicd::Segment *)((mem::ScopedCloneablePtr< six::sicd::Segment > const *)arg1)->operator ->(); + } + catch (const std::exception& e) + { + if (!PyErr_Occurred()) + { + PyErr_SetString(PyExc_RuntimeError, e.what()); + } + } + catch (const except::Exception& e) + { + if (!PyErr_Occurred()) + { + PyErr_SetString(PyExc_RuntimeError, e.getMessage().c_str()); + } + } + catch (...) + { + if (!PyErr_Occurred()) + { + PyErr_SetString(PyExc_RuntimeError, "Unknown error"); + } + } + if (PyErr_Occurred()) + { + SWIG_fail; + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_six__sicd__Segment, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ScopedCloneableSegment_reset__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mem::ScopedCloneablePtr< six::sicd::Segment > *arg1 = (mem::ScopedCloneablePtr< six::sicd::Segment > *) 0 ; + six::sicd::Segment *arg2 = (six::sicd::Segment *) 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:ScopedCloneableSegment_reset",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__Segment_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedCloneableSegment_reset" "', argument " "1"" of type '" "mem::ScopedCloneablePtr< six::sicd::Segment > *""'"); + } + arg1 = reinterpret_cast< mem::ScopedCloneablePtr< six::sicd::Segment > * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_six__sicd__Segment, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScopedCloneableSegment_reset" "', argument " "2"" of type '" "six::sicd::Segment *""'"); + } + arg2 = reinterpret_cast< six::sicd::Segment * >(argp2); + { + try + { + (arg1)->reset(arg2); + } + catch (const std::exception& e) + { + if (!PyErr_Occurred()) + { + PyErr_SetString(PyExc_RuntimeError, e.what()); + } + } + catch (const except::Exception& e) + { + if (!PyErr_Occurred()) + { + PyErr_SetString(PyExc_RuntimeError, e.getMessage().c_str()); + } + } + catch (...) + { + if (!PyErr_Occurred()) + { + PyErr_SetString(PyExc_RuntimeError, "Unknown error"); + } + } + if (PyErr_Occurred()) + { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ScopedCloneableSegment_reset__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mem::ScopedCloneablePtr< six::sicd::Segment > *arg1 = (mem::ScopedCloneablePtr< six::sicd::Segment > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:ScopedCloneableSegment_reset",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__Segment_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedCloneableSegment_reset" "', argument " "1"" of type '" "mem::ScopedCloneablePtr< six::sicd::Segment > *""'"); + } + arg1 = reinterpret_cast< mem::ScopedCloneablePtr< six::sicd::Segment > * >(argp1); + { + try + { + (arg1)->reset(); + } + catch (const std::exception& e) + { + if (!PyErr_Occurred()) + { + PyErr_SetString(PyExc_RuntimeError, e.what()); + } + } + catch (const except::Exception& e) + { + if (!PyErr_Occurred()) + { + PyErr_SetString(PyExc_RuntimeError, e.getMessage().c_str()); + } + } + catch (...) + { + if (!PyErr_Occurred()) + { + PyErr_SetString(PyExc_RuntimeError, "Unknown error"); + } + } + if (PyErr_Occurred()) + { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ScopedCloneableSegment_reset(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + int ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = args ? (int)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_mem__ScopedCloneablePtrT_six__sicd__Segment_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_ScopedCloneableSegment_reset__SWIG_1(self, args); + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__Segment_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_six__sicd__Segment, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_ScopedCloneableSegment_reset__SWIG_0(self, args); + } + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ScopedCloneableSegment_reset'.\n" + " Possible C/C++ prototypes are:\n" + " mem::ScopedCloneablePtr< six::sicd::Segment >::reset(six::sicd::Segment *)\n" + " mem::ScopedCloneablePtr< six::sicd::Segment >::reset()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_delete_ScopedCloneableSegment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mem::ScopedCloneablePtr< six::sicd::Segment > *arg1 = (mem::ScopedCloneablePtr< six::sicd::Segment > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:delete_ScopedCloneableSegment",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__Segment_t, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ScopedCloneableSegment" "', argument " "1"" of type '" "mem::ScopedCloneablePtr< six::sicd::Segment > *""'"); + } + arg1 = reinterpret_cast< mem::ScopedCloneablePtr< six::sicd::Segment > * >(argp1); + { + try + { + delete arg1; + } + catch (const std::exception& e) + { + if (!PyErr_Occurred()) + { + PyErr_SetString(PyExc_RuntimeError, e.what()); + } + } + catch (const except::Exception& e) + { + if (!PyErr_Occurred()) + { + PyErr_SetString(PyExc_RuntimeError, e.getMessage().c_str()); + } + } + catch (...) + { + if (!PyErr_Occurred()) + { + PyErr_SetString(PyExc_RuntimeError, "Unknown error"); + } + } + if (PyErr_Occurred()) + { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ScopedCloneableSegment_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mem::ScopedCloneablePtr< six::sicd::Segment > *arg1 = (mem::ScopedCloneablePtr< six::sicd::Segment > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + six::sicd::Segment *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:ScopedCloneableSegment_clone",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__Segment_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedCloneableSegment_clone" "', argument " "1"" of type '" "mem::ScopedCloneablePtr< six::sicd::Segment > const *""'"); + } + arg1 = reinterpret_cast< mem::ScopedCloneablePtr< six::sicd::Segment > * >(argp1); + { + try + { + result = (six::sicd::Segment *)(*arg1)->clone(); + } + catch (const std::exception& e) + { + if (!PyErr_Occurred()) + { + PyErr_SetString(PyExc_RuntimeError, e.what()); + } + } + catch (const except::Exception& e) + { + if (!PyErr_Occurred()) + { + PyErr_SetString(PyExc_RuntimeError, e.getMessage().c_str()); + } + } + catch (...) + { + if (!PyErr_Occurred()) + { + PyErr_SetString(PyExc_RuntimeError, "Unknown error"); + } + } + if (PyErr_Occurred()) + { + SWIG_fail; + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_six__sicd__Segment, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ScopedCloneableSegment_getNumLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mem::ScopedCloneablePtr< six::sicd::Segment > *arg1 = (mem::ScopedCloneablePtr< six::sicd::Segment > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + int result; + + if (!PyArg_ParseTuple(args,(char *)"O:ScopedCloneableSegment_getNumLines",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__Segment_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedCloneableSegment_getNumLines" "', argument " "1"" of type '" "mem::ScopedCloneablePtr< six::sicd::Segment > const *""'"); + } + arg1 = reinterpret_cast< mem::ScopedCloneablePtr< six::sicd::Segment > * >(argp1); + { + try + { + result = (int)(*arg1)->getNumLines(); + } + catch (const std::exception& e) + { + if (!PyErr_Occurred()) + { + PyErr_SetString(PyExc_RuntimeError, e.what()); + } + } + catch (const except::Exception& e) + { + if (!PyErr_Occurred()) + { + PyErr_SetString(PyExc_RuntimeError, e.getMessage().c_str()); + } + } + catch (...) + { + if (!PyErr_Occurred()) + { + PyErr_SetString(PyExc_RuntimeError, "Unknown error"); + } + } + if (PyErr_Occurred()) + { + SWIG_fail; + } + } + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ScopedCloneableSegment_getNumSamples(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mem::ScopedCloneablePtr< six::sicd::Segment > *arg1 = (mem::ScopedCloneablePtr< six::sicd::Segment > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + int result; + + if (!PyArg_ParseTuple(args,(char *)"O:ScopedCloneableSegment_getNumSamples",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__Segment_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedCloneableSegment_getNumSamples" "', argument " "1"" of type '" "mem::ScopedCloneablePtr< six::sicd::Segment > const *""'"); + } + arg1 = reinterpret_cast< mem::ScopedCloneablePtr< six::sicd::Segment > * >(argp1); + { + try + { + result = (int)(*arg1)->getNumSamples(); + } + catch (const std::exception& e) + { + if (!PyErr_Occurred()) + { + PyErr_SetString(PyExc_RuntimeError, e.what()); + } + } + catch (const except::Exception& e) + { + if (!PyErr_Occurred()) + { + PyErr_SetString(PyExc_RuntimeError, e.getMessage().c_str()); + } + } + catch (...) + { + if (!PyErr_Occurred()) + { + PyErr_SetString(PyExc_RuntimeError, "Unknown error"); + } + } + if (PyErr_Occurred()) + { + SWIG_fail; + } + } + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ScopedCloneableSegment_startLine_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mem::ScopedCloneablePtr< six::sicd::Segment > *arg1 = (mem::ScopedCloneablePtr< six::sicd::Segment > *) 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:ScopedCloneableSegment_startLine_set",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__Segment_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedCloneableSegment_startLine_set" "', argument " "1"" of type '" "mem::ScopedCloneablePtr< six::sicd::Segment > *""'"); + } + arg1 = reinterpret_cast< mem::ScopedCloneablePtr< six::sicd::Segment > * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScopedCloneableSegment_startLine_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + { + try + { + if (arg1) (*arg1)->startLine = arg2; + } + catch (const std::exception& e) + { + if (!PyErr_Occurred()) + { + PyErr_SetString(PyExc_RuntimeError, e.what()); + } + } + catch (const except::Exception& e) + { + if (!PyErr_Occurred()) + { + PyErr_SetString(PyExc_RuntimeError, e.getMessage().c_str()); + } + } + catch (...) + { + if (!PyErr_Occurred()) + { + PyErr_SetString(PyExc_RuntimeError, "Unknown error"); + } + } + if (PyErr_Occurred()) + { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ScopedCloneableSegment_startLine_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mem::ScopedCloneablePtr< six::sicd::Segment > *arg1 = (mem::ScopedCloneablePtr< six::sicd::Segment > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + int result; + + if (!PyArg_ParseTuple(args,(char *)"O:ScopedCloneableSegment_startLine_get",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__Segment_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedCloneableSegment_startLine_get" "', argument " "1"" of type '" "mem::ScopedCloneablePtr< six::sicd::Segment > *""'"); + } + arg1 = reinterpret_cast< mem::ScopedCloneablePtr< six::sicd::Segment > * >(argp1); + { + try + { + result = (int) ((*arg1)->startLine); + } + catch (const std::exception& e) + { + if (!PyErr_Occurred()) + { + PyErr_SetString(PyExc_RuntimeError, e.what()); + } + } + catch (const except::Exception& e) + { + if (!PyErr_Occurred()) + { + PyErr_SetString(PyExc_RuntimeError, e.getMessage().c_str()); + } + } + catch (...) + { + if (!PyErr_Occurred()) + { + PyErr_SetString(PyExc_RuntimeError, "Unknown error"); + } + } + if (PyErr_Occurred()) + { + SWIG_fail; + } + } + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ScopedCloneableSegment_startSample_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mem::ScopedCloneablePtr< six::sicd::Segment > *arg1 = (mem::ScopedCloneablePtr< six::sicd::Segment > *) 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:ScopedCloneableSegment_startSample_set",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__Segment_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedCloneableSegment_startSample_set" "', argument " "1"" of type '" "mem::ScopedCloneablePtr< six::sicd::Segment > *""'"); + } + arg1 = reinterpret_cast< mem::ScopedCloneablePtr< six::sicd::Segment > * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScopedCloneableSegment_startSample_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + { + try + { + if (arg1) (*arg1)->startSample = arg2; + } + catch (const std::exception& e) + { + if (!PyErr_Occurred()) + { + PyErr_SetString(PyExc_RuntimeError, e.what()); + } + } + catch (const except::Exception& e) + { + if (!PyErr_Occurred()) + { + PyErr_SetString(PyExc_RuntimeError, e.getMessage().c_str()); + } + } + catch (...) + { + if (!PyErr_Occurred()) + { + PyErr_SetString(PyExc_RuntimeError, "Unknown error"); + } + } + if (PyErr_Occurred()) + { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ScopedCloneableSegment_startSample_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mem::ScopedCloneablePtr< six::sicd::Segment > *arg1 = (mem::ScopedCloneablePtr< six::sicd::Segment > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + int result; + + if (!PyArg_ParseTuple(args,(char *)"O:ScopedCloneableSegment_startSample_get",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__Segment_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedCloneableSegment_startSample_get" "', argument " "1"" of type '" "mem::ScopedCloneablePtr< six::sicd::Segment > *""'"); + } + arg1 = reinterpret_cast< mem::ScopedCloneablePtr< six::sicd::Segment > * >(argp1); + { + try + { + result = (int) ((*arg1)->startSample); + } + catch (const std::exception& e) + { + if (!PyErr_Occurred()) + { + PyErr_SetString(PyExc_RuntimeError, e.what()); + } + } + catch (const except::Exception& e) + { + if (!PyErr_Occurred()) + { + PyErr_SetString(PyExc_RuntimeError, e.getMessage().c_str()); + } + } + catch (...) + { + if (!PyErr_Occurred()) + { + PyErr_SetString(PyExc_RuntimeError, "Unknown error"); + } + } + if (PyErr_Occurred()) + { + SWIG_fail; + } + } + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ScopedCloneableSegment_endLine_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mem::ScopedCloneablePtr< six::sicd::Segment > *arg1 = (mem::ScopedCloneablePtr< six::sicd::Segment > *) 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:ScopedCloneableSegment_endLine_set",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__Segment_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedCloneableSegment_endLine_set" "', argument " "1"" of type '" "mem::ScopedCloneablePtr< six::sicd::Segment > *""'"); + } + arg1 = reinterpret_cast< mem::ScopedCloneablePtr< six::sicd::Segment > * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScopedCloneableSegment_endLine_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + { + try + { + if (arg1) (*arg1)->endLine = arg2; + } + catch (const std::exception& e) + { + if (!PyErr_Occurred()) + { + PyErr_SetString(PyExc_RuntimeError, e.what()); + } + } + catch (const except::Exception& e) + { + if (!PyErr_Occurred()) + { + PyErr_SetString(PyExc_RuntimeError, e.getMessage().c_str()); + } + } + catch (...) + { + if (!PyErr_Occurred()) + { + PyErr_SetString(PyExc_RuntimeError, "Unknown error"); + } + } + if (PyErr_Occurred()) + { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ScopedCloneableSegment_endLine_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mem::ScopedCloneablePtr< six::sicd::Segment > *arg1 = (mem::ScopedCloneablePtr< six::sicd::Segment > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + int result; + + if (!PyArg_ParseTuple(args,(char *)"O:ScopedCloneableSegment_endLine_get",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__Segment_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedCloneableSegment_endLine_get" "', argument " "1"" of type '" "mem::ScopedCloneablePtr< six::sicd::Segment > *""'"); + } + arg1 = reinterpret_cast< mem::ScopedCloneablePtr< six::sicd::Segment > * >(argp1); + { + try + { + result = (int) ((*arg1)->endLine); + } + catch (const std::exception& e) + { + if (!PyErr_Occurred()) + { + PyErr_SetString(PyExc_RuntimeError, e.what()); + } + } + catch (const except::Exception& e) + { + if (!PyErr_Occurred()) + { + PyErr_SetString(PyExc_RuntimeError, e.getMessage().c_str()); + } + } + catch (...) + { + if (!PyErr_Occurred()) + { + PyErr_SetString(PyExc_RuntimeError, "Unknown error"); + } + } + if (PyErr_Occurred()) + { + SWIG_fail; + } + } + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ScopedCloneableSegment_endSample_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mem::ScopedCloneablePtr< six::sicd::Segment > *arg1 = (mem::ScopedCloneablePtr< six::sicd::Segment > *) 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:ScopedCloneableSegment_endSample_set",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__Segment_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedCloneableSegment_endSample_set" "', argument " "1"" of type '" "mem::ScopedCloneablePtr< six::sicd::Segment > *""'"); + } + arg1 = reinterpret_cast< mem::ScopedCloneablePtr< six::sicd::Segment > * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScopedCloneableSegment_endSample_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + { + try + { + if (arg1) (*arg1)->endSample = arg2; + } + catch (const std::exception& e) + { + if (!PyErr_Occurred()) + { + PyErr_SetString(PyExc_RuntimeError, e.what()); + } + } + catch (const except::Exception& e) + { + if (!PyErr_Occurred()) + { + PyErr_SetString(PyExc_RuntimeError, e.getMessage().c_str()); + } + } + catch (...) + { + if (!PyErr_Occurred()) + { + PyErr_SetString(PyExc_RuntimeError, "Unknown error"); + } + } + if (PyErr_Occurred()) + { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ScopedCloneableSegment_endSample_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mem::ScopedCloneablePtr< six::sicd::Segment > *arg1 = (mem::ScopedCloneablePtr< six::sicd::Segment > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + int result; + + if (!PyArg_ParseTuple(args,(char *)"O:ScopedCloneableSegment_endSample_get",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__Segment_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedCloneableSegment_endSample_get" "', argument " "1"" of type '" "mem::ScopedCloneablePtr< six::sicd::Segment > *""'"); + } + arg1 = reinterpret_cast< mem::ScopedCloneablePtr< six::sicd::Segment > * >(argp1); + { + try + { + result = (int) ((*arg1)->endSample); + } + catch (const std::exception& e) + { + if (!PyErr_Occurred()) + { + PyErr_SetString(PyExc_RuntimeError, e.what()); + } + } + catch (const except::Exception& e) + { + if (!PyErr_Occurred()) + { + PyErr_SetString(PyExc_RuntimeError, e.getMessage().c_str()); + } + } + catch (...) + { + if (!PyErr_Occurred()) + { + PyErr_SetString(PyExc_RuntimeError, "Unknown error"); + } + } + if (PyErr_Occurred()) + { + SWIG_fail; + } + } + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ScopedCloneableSegment_identifier_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mem::ScopedCloneablePtr< six::sicd::Segment > *arg1 = (mem::ScopedCloneablePtr< six::sicd::Segment > *) 0 ; + std::string *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int res2 = SWIG_OLDOBJ ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:ScopedCloneableSegment_identifier_set",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__Segment_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedCloneableSegment_identifier_set" "', argument " "1"" of type '" "mem::ScopedCloneablePtr< six::sicd::Segment > *""'"); + } + arg1 = reinterpret_cast< mem::ScopedCloneablePtr< six::sicd::Segment > * >(argp1); + { + std::string *ptr = (std::string *)0; + res2 = SWIG_AsPtr_std_string(obj1, &ptr); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScopedCloneableSegment_identifier_set" "', argument " "2"" of type '" "std::string const &""'"); + } + if (!ptr) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ScopedCloneableSegment_identifier_set" "', argument " "2"" of type '" "std::string const &""'"); + } + arg2 = ptr; + } + { + try + { + if (arg1) (*arg1)->identifier = *arg2; + } + catch (const std::exception& e) + { + if (!PyErr_Occurred()) + { + PyErr_SetString(PyExc_RuntimeError, e.what()); + } + } + catch (const except::Exception& e) + { + if (!PyErr_Occurred()) + { + PyErr_SetString(PyExc_RuntimeError, e.getMessage().c_str()); + } + } + catch (...) + { + if (!PyErr_Occurred()) + { + PyErr_SetString(PyExc_RuntimeError, "Unknown error"); + } + } + if (PyErr_Occurred()) + { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + if (SWIG_IsNewObj(res2)) delete arg2; + return resultobj; +fail: + if (SWIG_IsNewObj(res2)) delete arg2; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ScopedCloneableSegment_identifier_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mem::ScopedCloneablePtr< six::sicd::Segment > *arg1 = (mem::ScopedCloneablePtr< six::sicd::Segment > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::string *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:ScopedCloneableSegment_identifier_get",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__Segment_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedCloneableSegment_identifier_get" "', argument " "1"" of type '" "mem::ScopedCloneablePtr< six::sicd::Segment > *""'"); + } + arg1 = reinterpret_cast< mem::ScopedCloneablePtr< six::sicd::Segment > * >(argp1); + { + try + { + result = (std::string *) & ((*arg1)->identifier); + } + catch (const std::exception& e) + { + if (!PyErr_Occurred()) + { + PyErr_SetString(PyExc_RuntimeError, e.what()); + } + } + catch (const except::Exception& e) + { + if (!PyErr_Occurred()) + { + PyErr_SetString(PyExc_RuntimeError, e.getMessage().c_str()); + } + } + catch (...) + { + if (!PyErr_Occurred()) + { + PyErr_SetString(PyExc_RuntimeError, "Unknown error"); + } + } + if (PyErr_Occurred()) + { + SWIG_fail; + } + } + resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *ScopedCloneableSegment_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__Segment_t, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *_wrap_new_ScopedCloneableTxStep__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + six::sicd::TxStep *arg1 = (six::sicd::TxStep *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + mem::ScopedCloneablePtr< six::sicd::TxStep > *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:new_ScopedCloneableTxStep",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_six__sicd__TxStep, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ScopedCloneableTxStep" "', argument " "1"" of type '" "six::sicd::TxStep *""'"); + } + arg1 = reinterpret_cast< six::sicd::TxStep * >(argp1); + { + try + { + result = (mem::ScopedCloneablePtr< six::sicd::TxStep > *)new mem::ScopedCloneablePtr< six::sicd::TxStep >(arg1); + } + catch (const std::exception& e) + { + if (!PyErr_Occurred()) + { + PyErr_SetString(PyExc_RuntimeError, e.what()); + } + } + catch (const except::Exception& e) + { + if (!PyErr_Occurred()) + { + PyErr_SetString(PyExc_RuntimeError, e.getMessage().c_str()); + } + } + catch (...) + { + if (!PyErr_Occurred()) + { + PyErr_SetString(PyExc_RuntimeError, "Unknown error"); + } + } + if (PyErr_Occurred()) + { + SWIG_fail; + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__TxStep_t, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_ScopedCloneableTxStep__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mem::ScopedCloneablePtr< six::sicd::TxStep > *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)":new_ScopedCloneableTxStep")) SWIG_fail; + { + try + { + result = (mem::ScopedCloneablePtr< six::sicd::TxStep > *)new mem::ScopedCloneablePtr< six::sicd::TxStep >(); + } + catch (const std::exception& e) + { + if (!PyErr_Occurred()) + { + PyErr_SetString(PyExc_RuntimeError, e.what()); + } + } + catch (const except::Exception& e) + { + if (!PyErr_Occurred()) + { + PyErr_SetString(PyExc_RuntimeError, e.getMessage().c_str()); + } + } + catch (...) + { + if (!PyErr_Occurred()) + { + PyErr_SetString(PyExc_RuntimeError, "Unknown error"); + } + } + if (PyErr_Occurred()) + { + SWIG_fail; + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__TxStep_t, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_ScopedCloneableTxStep__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mem::ScopedCloneablePtr< six::sicd::TxStep > *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + mem::ScopedCloneablePtr< six::sicd::TxStep > *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:new_ScopedCloneableTxStep",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__TxStep_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ScopedCloneableTxStep" "', argument " "1"" of type '" "mem::ScopedCloneablePtr< six::sicd::TxStep > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ScopedCloneableTxStep" "', argument " "1"" of type '" "mem::ScopedCloneablePtr< six::sicd::TxStep > const &""'"); + } + arg1 = reinterpret_cast< mem::ScopedCloneablePtr< six::sicd::TxStep > * >(argp1); + { + try + { + result = (mem::ScopedCloneablePtr< six::sicd::TxStep > *)new mem::ScopedCloneablePtr< six::sicd::TxStep >((mem::ScopedCloneablePtr< six::sicd::TxStep > const &)*arg1); + } + catch (const std::exception& e) + { + if (!PyErr_Occurred()) + { + PyErr_SetString(PyExc_RuntimeError, e.what()); + } + } + catch (const except::Exception& e) + { + if (!PyErr_Occurred()) + { + PyErr_SetString(PyExc_RuntimeError, e.getMessage().c_str()); + } + } + catch (...) + { + if (!PyErr_Occurred()) + { + PyErr_SetString(PyExc_RuntimeError, "Unknown error"); + } + } + if (PyErr_Occurred()) + { + SWIG_fail; + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__TxStep_t, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_ScopedCloneableTxStep(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[2]; + int ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = args ? (int)PyObject_Length(args) : 0; + for (ii = 0; (ii < 1) && (ii < argc); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); + } + if (argc == 0) { + return _wrap_new_ScopedCloneableTxStep__SWIG_1(self, args); + } + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_six__sicd__TxStep, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_ScopedCloneableTxStep__SWIG_0(self, args); + } + } + if (argc == 1) { + int _v; + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__TxStep_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_ScopedCloneableTxStep__SWIG_2(self, args); + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ScopedCloneableTxStep'.\n" + " Possible C/C++ prototypes are:\n" + " mem::ScopedCloneablePtr< six::sicd::TxStep >::ScopedCloneablePtr(six::sicd::TxStep *)\n" + " mem::ScopedCloneablePtr< six::sicd::TxStep >::ScopedCloneablePtr()\n" + " mem::ScopedCloneablePtr< six::sicd::TxStep >::ScopedCloneablePtr(mem::ScopedCloneablePtr< six::sicd::TxStep > const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_ScopedCloneableTxStep_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mem::ScopedCloneablePtr< six::sicd::TxStep > *arg1 = (mem::ScopedCloneablePtr< six::sicd::TxStep > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + six::sicd::TxStep *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:ScopedCloneableTxStep_get",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__TxStep_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedCloneableTxStep_get" "', argument " "1"" of type '" "mem::ScopedCloneablePtr< six::sicd::TxStep > const *""'"); + } + arg1 = reinterpret_cast< mem::ScopedCloneablePtr< six::sicd::TxStep > * >(argp1); + { + try + { + result = (six::sicd::TxStep *)((mem::ScopedCloneablePtr< six::sicd::TxStep > const *)arg1)->get(); + } + catch (const std::exception& e) + { + if (!PyErr_Occurred()) + { + PyErr_SetString(PyExc_RuntimeError, e.what()); + } + } + catch (const except::Exception& e) + { + if (!PyErr_Occurred()) + { + PyErr_SetString(PyExc_RuntimeError, e.getMessage().c_str()); + } + } + catch (...) + { + if (!PyErr_Occurred()) + { + PyErr_SetString(PyExc_RuntimeError, "Unknown error"); + } + } + if (PyErr_Occurred()) + { + SWIG_fail; + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_six__sicd__TxStep, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ScopedCloneableTxStep___ref__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mem::ScopedCloneablePtr< six::sicd::TxStep > *arg1 = (mem::ScopedCloneablePtr< six::sicd::TxStep > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + six::sicd::TxStep *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:ScopedCloneableTxStep___ref__",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__TxStep_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedCloneableTxStep___ref__" "', argument " "1"" of type '" "mem::ScopedCloneablePtr< six::sicd::TxStep > const *""'"); + } + arg1 = reinterpret_cast< mem::ScopedCloneablePtr< six::sicd::TxStep > * >(argp1); + { + try + { + result = (six::sicd::TxStep *) &((mem::ScopedCloneablePtr< six::sicd::TxStep > const *)arg1)->operator *(); + } + catch (const std::exception& e) + { + if (!PyErr_Occurred()) + { + PyErr_SetString(PyExc_RuntimeError, e.what()); + } + } + catch (const except::Exception& e) + { + if (!PyErr_Occurred()) + { + PyErr_SetString(PyExc_RuntimeError, e.getMessage().c_str()); + } + } + catch (...) + { + if (!PyErr_Occurred()) + { + PyErr_SetString(PyExc_RuntimeError, "Unknown error"); + } + } + if (PyErr_Occurred()) + { + SWIG_fail; + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_six__sicd__TxStep, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ScopedCloneableTxStep___deref__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mem::ScopedCloneablePtr< six::sicd::TxStep > *arg1 = (mem::ScopedCloneablePtr< six::sicd::TxStep > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + six::sicd::TxStep *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:ScopedCloneableTxStep___deref__",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mem__ScopedCloneablePtrT_six__sicd__TxStep_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScopedCloneableTxStep___deref__" "', argument " "1"" of type '" "mem::ScopedCloneablePtr< six::sicd::TxStep > const *""'"); + } + arg1 = reinterpret_cast< mem::ScopedCloneablePtr< six::sicd::TxStep > * >(argp1); + { + try + { + result = (six::sicd::TxStep *)((mem::ScopedCloneablePtr< six::sicd::TxStep > const *)arg1)->operator ->(); } catch (const std::exception& e) { @@ -129252,10 +131094,10 @@ static PyMethodDef SwigMethods[] = { { (char *)"Grid_type_get", _wrap_Grid_type_get, METH_VARARGS, (char *)"Grid_type_get(Grid self) -> ComplexImageGridType"}, { (char *)"Grid_timeCOAPoly_set", _wrap_Grid_timeCOAPoly_set, METH_VARARGS, (char *)"Grid_timeCOAPoly_set(Grid self, Poly2D timeCOAPoly)"}, { (char *)"Grid_timeCOAPoly_get", _wrap_Grid_timeCOAPoly_get, METH_VARARGS, (char *)"Grid_timeCOAPoly_get(Grid self) -> Poly2D"}, - { (char *)"Grid_row_set", _wrap_Grid_row_set, METH_VARARGS, (char *)"Grid_row_set(Grid self, mem::ScopedCloneablePtr< six::sicd::DirectionParameters > * row)"}, - { (char *)"Grid_row_get", _wrap_Grid_row_get, METH_VARARGS, (char *)"Grid_row_get(Grid self) -> mem::ScopedCloneablePtr< six::sicd::DirectionParameters > *"}, - { (char *)"Grid_col_set", _wrap_Grid_col_set, METH_VARARGS, (char *)"Grid_col_set(Grid self, mem::ScopedCloneablePtr< six::sicd::DirectionParameters > * col)"}, - { (char *)"Grid_col_get", _wrap_Grid_col_get, METH_VARARGS, (char *)"Grid_col_get(Grid self) -> mem::ScopedCloneablePtr< six::sicd::DirectionParameters > *"}, + { (char *)"Grid_row_set", _wrap_Grid_row_set, METH_VARARGS, (char *)"Grid_row_set(Grid self, ScopedCloneableDirectionParameters row)"}, + { (char *)"Grid_row_get", _wrap_Grid_row_get, METH_VARARGS, (char *)"Grid_row_get(Grid self) -> ScopedCloneableDirectionParameters"}, + { (char *)"Grid_col_set", _wrap_Grid_col_set, METH_VARARGS, (char *)"Grid_col_set(Grid self, ScopedCloneableDirectionParameters col)"}, + { (char *)"Grid_col_get", _wrap_Grid_col_get, METH_VARARGS, (char *)"Grid_col_get(Grid self) -> ScopedCloneableDirectionParameters"}, { (char *)"delete_Grid", _wrap_delete_Grid, METH_VARARGS, (char *)"delete_Grid(Grid self)"}, { (char *)"Grid_swigregister", Grid_swigregister, METH_VARARGS, NULL}, { (char *)"TimelineSet_tStart_set", _wrap_TimelineSet_tStart_set, METH_VARARGS, (char *)"TimelineSet_tStart_set(TimelineSet self, double tStart)"}, @@ -129380,10 +131222,10 @@ static PyMethodDef SwigMethods[] = { { (char *)"AreaPlane_clone", _wrap_AreaPlane_clone, METH_VARARGS, (char *)"AreaPlane_clone(AreaPlane self) -> AreaPlane"}, { (char *)"AreaPlane_referencePoint_set", _wrap_AreaPlane_referencePoint_set, METH_VARARGS, (char *)"AreaPlane_referencePoint_set(AreaPlane self, ReferencePoint referencePoint)"}, { (char *)"AreaPlane_referencePoint_get", _wrap_AreaPlane_referencePoint_get, METH_VARARGS, (char *)"AreaPlane_referencePoint_get(AreaPlane self) -> ReferencePoint"}, - { (char *)"AreaPlane_xDirection_set", _wrap_AreaPlane_xDirection_set, METH_VARARGS, (char *)"AreaPlane_xDirection_set(AreaPlane self, mem::ScopedCloneablePtr< six::sicd::AreaDirectionParameters > * xDirection)"}, - { (char *)"AreaPlane_xDirection_get", _wrap_AreaPlane_xDirection_get, METH_VARARGS, (char *)"AreaPlane_xDirection_get(AreaPlane self) -> mem::ScopedCloneablePtr< six::sicd::AreaDirectionParameters > *"}, - { (char *)"AreaPlane_yDirection_set", _wrap_AreaPlane_yDirection_set, METH_VARARGS, (char *)"AreaPlane_yDirection_set(AreaPlane self, mem::ScopedCloneablePtr< six::sicd::AreaDirectionParameters > * yDirection)"}, - { (char *)"AreaPlane_yDirection_get", _wrap_AreaPlane_yDirection_get, METH_VARARGS, (char *)"AreaPlane_yDirection_get(AreaPlane self) -> mem::ScopedCloneablePtr< six::sicd::AreaDirectionParameters > *"}, + { (char *)"AreaPlane_xDirection_set", _wrap_AreaPlane_xDirection_set, METH_VARARGS, (char *)"AreaPlane_xDirection_set(AreaPlane self, ScopedCloneableAreaDirectionParameters xDirection)"}, + { (char *)"AreaPlane_xDirection_get", _wrap_AreaPlane_xDirection_get, METH_VARARGS, (char *)"AreaPlane_xDirection_get(AreaPlane self) -> ScopedCloneableAreaDirectionParameters"}, + { (char *)"AreaPlane_yDirection_set", _wrap_AreaPlane_yDirection_set, METH_VARARGS, (char *)"AreaPlane_yDirection_set(AreaPlane self, ScopedCloneableAreaDirectionParameters yDirection)"}, + { (char *)"AreaPlane_yDirection_get", _wrap_AreaPlane_yDirection_get, METH_VARARGS, (char *)"AreaPlane_yDirection_get(AreaPlane self) -> ScopedCloneableAreaDirectionParameters"}, { (char *)"AreaPlane_segmentList_set", _wrap_AreaPlane_segmentList_set, METH_VARARGS, (char *)"AreaPlane_segmentList_set(AreaPlane self, vectorScopedClonableSegment segmentList)"}, { (char *)"AreaPlane_segmentList_get", _wrap_AreaPlane_segmentList_get, METH_VARARGS, (char *)"AreaPlane_segmentList_get(AreaPlane self) -> vectorScopedClonableSegment"}, { (char *)"AreaPlane_orientation_set", _wrap_AreaPlane_orientation_set, METH_VARARGS, (char *)"AreaPlane_orientation_set(AreaPlane self, OrientationType orientation)"}, @@ -129945,10 +131787,10 @@ static PyMethodDef SwigMethods[] = { { (char *)"ScopedCloneableGrid_type_get", _wrap_ScopedCloneableGrid_type_get, METH_VARARGS, (char *)"ScopedCloneableGrid_type_get(ScopedCloneableGrid self) -> ComplexImageGridType"}, { (char *)"ScopedCloneableGrid_timeCOAPoly_set", _wrap_ScopedCloneableGrid_timeCOAPoly_set, METH_VARARGS, (char *)"ScopedCloneableGrid_timeCOAPoly_set(ScopedCloneableGrid self, Poly2D timeCOAPoly)"}, { (char *)"ScopedCloneableGrid_timeCOAPoly_get", _wrap_ScopedCloneableGrid_timeCOAPoly_get, METH_VARARGS, (char *)"ScopedCloneableGrid_timeCOAPoly_get(ScopedCloneableGrid self) -> Poly2D"}, - { (char *)"ScopedCloneableGrid_row_set", _wrap_ScopedCloneableGrid_row_set, METH_VARARGS, (char *)"ScopedCloneableGrid_row_set(ScopedCloneableGrid self, mem::ScopedCloneablePtr< six::sicd::DirectionParameters > * row)"}, - { (char *)"ScopedCloneableGrid_row_get", _wrap_ScopedCloneableGrid_row_get, METH_VARARGS, (char *)"ScopedCloneableGrid_row_get(ScopedCloneableGrid self) -> mem::ScopedCloneablePtr< six::sicd::DirectionParameters > *"}, - { (char *)"ScopedCloneableGrid_col_set", _wrap_ScopedCloneableGrid_col_set, METH_VARARGS, (char *)"ScopedCloneableGrid_col_set(ScopedCloneableGrid self, mem::ScopedCloneablePtr< six::sicd::DirectionParameters > * col)"}, - { (char *)"ScopedCloneableGrid_col_get", _wrap_ScopedCloneableGrid_col_get, METH_VARARGS, (char *)"ScopedCloneableGrid_col_get(ScopedCloneableGrid self) -> mem::ScopedCloneablePtr< six::sicd::DirectionParameters > *"}, + { (char *)"ScopedCloneableGrid_row_set", _wrap_ScopedCloneableGrid_row_set, METH_VARARGS, (char *)"ScopedCloneableGrid_row_set(ScopedCloneableGrid self, ScopedCloneableDirectionParameters row)"}, + { (char *)"ScopedCloneableGrid_row_get", _wrap_ScopedCloneableGrid_row_get, METH_VARARGS, (char *)"ScopedCloneableGrid_row_get(ScopedCloneableGrid self) -> ScopedCloneableDirectionParameters"}, + { (char *)"ScopedCloneableGrid_col_set", _wrap_ScopedCloneableGrid_col_set, METH_VARARGS, (char *)"ScopedCloneableGrid_col_set(ScopedCloneableGrid self, ScopedCloneableDirectionParameters col)"}, + { (char *)"ScopedCloneableGrid_col_get", _wrap_ScopedCloneableGrid_col_get, METH_VARARGS, (char *)"ScopedCloneableGrid_col_get(ScopedCloneableGrid self) -> ScopedCloneableDirectionParameters"}, { (char *)"ScopedCloneableGrid_swigregister", ScopedCloneableGrid_swigregister, METH_VARARGS, NULL}, { (char *)"new_ScopedCloneableTimeline", _wrap_new_ScopedCloneableTimeline, METH_VARARGS, (char *)"\n" "ScopedCloneableTimeline(Timeline ptr=None)\n" @@ -130594,6 +132436,43 @@ static PyMethodDef SwigMethods[] = { { (char *)"VectorPolyXYZ_capacity", _wrap_VectorPolyXYZ_capacity, METH_VARARGS, (char *)"VectorPolyXYZ_capacity(VectorPolyXYZ self) -> std::vector< PolyXYZ >::size_type"}, { (char *)"delete_VectorPolyXYZ", _wrap_delete_VectorPolyXYZ, METH_VARARGS, (char *)"delete_VectorPolyXYZ(VectorPolyXYZ self)"}, { (char *)"VectorPolyXYZ_swigregister", VectorPolyXYZ_swigregister, METH_VARARGS, NULL}, + { (char *)"new_ScopedCloneableDirectionParameters", _wrap_new_ScopedCloneableDirectionParameters, METH_VARARGS, (char *)"\n" + "ScopedCloneableDirectionParameters(DirectionParameters ptr=None)\n" + "ScopedCloneableDirectionParameters()\n" + "new_ScopedCloneableDirectionParameters(ScopedCloneableDirectionParameters rhs) -> ScopedCloneableDirectionParameters\n" + ""}, + { (char *)"ScopedCloneableDirectionParameters_get", _wrap_ScopedCloneableDirectionParameters_get, METH_VARARGS, (char *)"ScopedCloneableDirectionParameters_get(ScopedCloneableDirectionParameters self) -> DirectionParameters"}, + { (char *)"ScopedCloneableDirectionParameters___ref__", _wrap_ScopedCloneableDirectionParameters___ref__, METH_VARARGS, (char *)"ScopedCloneableDirectionParameters___ref__(ScopedCloneableDirectionParameters self) -> DirectionParameters"}, + { (char *)"ScopedCloneableDirectionParameters___deref__", _wrap_ScopedCloneableDirectionParameters___deref__, METH_VARARGS, (char *)"ScopedCloneableDirectionParameters___deref__(ScopedCloneableDirectionParameters self) -> DirectionParameters"}, + { (char *)"ScopedCloneableDirectionParameters_reset", _wrap_ScopedCloneableDirectionParameters_reset, METH_VARARGS, (char *)"\n" + "reset(DirectionParameters ptr=None)\n" + "ScopedCloneableDirectionParameters_reset(ScopedCloneableDirectionParameters self)\n" + ""}, + { (char *)"delete_ScopedCloneableDirectionParameters", _wrap_delete_ScopedCloneableDirectionParameters, METH_VARARGS, (char *)"delete_ScopedCloneableDirectionParameters(ScopedCloneableDirectionParameters self)"}, + { (char *)"ScopedCloneableDirectionParameters_clone", _wrap_ScopedCloneableDirectionParameters_clone, METH_VARARGS, (char *)"ScopedCloneableDirectionParameters_clone(ScopedCloneableDirectionParameters self) -> DirectionParameters"}, + { (char *)"ScopedCloneableDirectionParameters_unitVector_set", _wrap_ScopedCloneableDirectionParameters_unitVector_set, METH_VARARGS, (char *)"ScopedCloneableDirectionParameters_unitVector_set(ScopedCloneableDirectionParameters self, Vector3 unitVector)"}, + { (char *)"ScopedCloneableDirectionParameters_unitVector_get", _wrap_ScopedCloneableDirectionParameters_unitVector_get, METH_VARARGS, (char *)"ScopedCloneableDirectionParameters_unitVector_get(ScopedCloneableDirectionParameters self) -> Vector3"}, + { (char *)"ScopedCloneableDirectionParameters_sampleSpacing_set", _wrap_ScopedCloneableDirectionParameters_sampleSpacing_set, METH_VARARGS, (char *)"ScopedCloneableDirectionParameters_sampleSpacing_set(ScopedCloneableDirectionParameters self, double sampleSpacing)"}, + { (char *)"ScopedCloneableDirectionParameters_sampleSpacing_get", _wrap_ScopedCloneableDirectionParameters_sampleSpacing_get, METH_VARARGS, (char *)"ScopedCloneableDirectionParameters_sampleSpacing_get(ScopedCloneableDirectionParameters self) -> double"}, + { (char *)"ScopedCloneableDirectionParameters_impulseResponseWidth_set", _wrap_ScopedCloneableDirectionParameters_impulseResponseWidth_set, METH_VARARGS, (char *)"ScopedCloneableDirectionParameters_impulseResponseWidth_set(ScopedCloneableDirectionParameters self, double impulseResponseWidth)"}, + { (char *)"ScopedCloneableDirectionParameters_impulseResponseWidth_get", _wrap_ScopedCloneableDirectionParameters_impulseResponseWidth_get, METH_VARARGS, (char *)"ScopedCloneableDirectionParameters_impulseResponseWidth_get(ScopedCloneableDirectionParameters self) -> double"}, + { (char *)"ScopedCloneableDirectionParameters_sign_set", _wrap_ScopedCloneableDirectionParameters_sign_set, METH_VARARGS, (char *)"ScopedCloneableDirectionParameters_sign_set(ScopedCloneableDirectionParameters self, FFTSign sign)"}, + { (char *)"ScopedCloneableDirectionParameters_sign_get", _wrap_ScopedCloneableDirectionParameters_sign_get, METH_VARARGS, (char *)"ScopedCloneableDirectionParameters_sign_get(ScopedCloneableDirectionParameters self) -> FFTSign"}, + { (char *)"ScopedCloneableDirectionParameters_impulseResponseBandwidth_set", _wrap_ScopedCloneableDirectionParameters_impulseResponseBandwidth_set, METH_VARARGS, (char *)"ScopedCloneableDirectionParameters_impulseResponseBandwidth_set(ScopedCloneableDirectionParameters self, double impulseResponseBandwidth)"}, + { (char *)"ScopedCloneableDirectionParameters_impulseResponseBandwidth_get", _wrap_ScopedCloneableDirectionParameters_impulseResponseBandwidth_get, METH_VARARGS, (char *)"ScopedCloneableDirectionParameters_impulseResponseBandwidth_get(ScopedCloneableDirectionParameters self) -> double"}, + { (char *)"ScopedCloneableDirectionParameters_kCenter_set", _wrap_ScopedCloneableDirectionParameters_kCenter_set, METH_VARARGS, (char *)"ScopedCloneableDirectionParameters_kCenter_set(ScopedCloneableDirectionParameters self, double kCenter)"}, + { (char *)"ScopedCloneableDirectionParameters_kCenter_get", _wrap_ScopedCloneableDirectionParameters_kCenter_get, METH_VARARGS, (char *)"ScopedCloneableDirectionParameters_kCenter_get(ScopedCloneableDirectionParameters self) -> double"}, + { (char *)"ScopedCloneableDirectionParameters_deltaK1_set", _wrap_ScopedCloneableDirectionParameters_deltaK1_set, METH_VARARGS, (char *)"ScopedCloneableDirectionParameters_deltaK1_set(ScopedCloneableDirectionParameters self, double deltaK1)"}, + { (char *)"ScopedCloneableDirectionParameters_deltaK1_get", _wrap_ScopedCloneableDirectionParameters_deltaK1_get, METH_VARARGS, (char *)"ScopedCloneableDirectionParameters_deltaK1_get(ScopedCloneableDirectionParameters self) -> double"}, + { (char *)"ScopedCloneableDirectionParameters_deltaK2_set", _wrap_ScopedCloneableDirectionParameters_deltaK2_set, METH_VARARGS, (char *)"ScopedCloneableDirectionParameters_deltaK2_set(ScopedCloneableDirectionParameters self, double deltaK2)"}, + { (char *)"ScopedCloneableDirectionParameters_deltaK2_get", _wrap_ScopedCloneableDirectionParameters_deltaK2_get, METH_VARARGS, (char *)"ScopedCloneableDirectionParameters_deltaK2_get(ScopedCloneableDirectionParameters self) -> double"}, + { (char *)"ScopedCloneableDirectionParameters_deltaKCOAPoly_set", _wrap_ScopedCloneableDirectionParameters_deltaKCOAPoly_set, METH_VARARGS, (char *)"ScopedCloneableDirectionParameters_deltaKCOAPoly_set(ScopedCloneableDirectionParameters self, Poly2D deltaKCOAPoly)"}, + { (char *)"ScopedCloneableDirectionParameters_deltaKCOAPoly_get", _wrap_ScopedCloneableDirectionParameters_deltaKCOAPoly_get, METH_VARARGS, (char *)"ScopedCloneableDirectionParameters_deltaKCOAPoly_get(ScopedCloneableDirectionParameters self) -> Poly2D"}, + { (char *)"ScopedCloneableDirectionParameters_weightType_set", _wrap_ScopedCloneableDirectionParameters_weightType_set, METH_VARARGS, (char *)"ScopedCloneableDirectionParameters_weightType_set(ScopedCloneableDirectionParameters self, ScopedCopyableWeightType weightType)"}, + { (char *)"ScopedCloneableDirectionParameters_weightType_get", _wrap_ScopedCloneableDirectionParameters_weightType_get, METH_VARARGS, (char *)"ScopedCloneableDirectionParameters_weightType_get(ScopedCloneableDirectionParameters self) -> ScopedCopyableWeightType"}, + { (char *)"ScopedCloneableDirectionParameters_weights_set", _wrap_ScopedCloneableDirectionParameters_weights_set, METH_VARARGS, (char *)"ScopedCloneableDirectionParameters_weights_set(ScopedCloneableDirectionParameters self, std_vector_double weights)"}, + { (char *)"ScopedCloneableDirectionParameters_weights_get", _wrap_ScopedCloneableDirectionParameters_weights_get, METH_VARARGS, (char *)"ScopedCloneableDirectionParameters_weights_get(ScopedCloneableDirectionParameters self) -> std_vector_double"}, + { (char *)"ScopedCloneableDirectionParameters_swigregister", ScopedCloneableDirectionParameters_swigregister, METH_VARARGS, NULL}, { (char *)"new_ScopedCloneableAreaDirectionParameters", _wrap_new_ScopedCloneableAreaDirectionParameters, METH_VARARGS, (char *)"\n" "ScopedCloneableAreaDirectionParameters(AreaDirectionParameters ptr=None)\n" "ScopedCloneableAreaDirectionParameters()\n" @@ -131639,7 +133518,6 @@ static swig_type_info _swigt__p_mem__ScopedCopyablePtrT_six__Radiometric_t = {"_ static swig_type_info _swigt__p_mem__ScopedCopyablePtrT_six__TropoError_t = {"_p_mem__ScopedCopyablePtrT_six__TropoError_t", "mem::ScopedCopyablePtr< six::TropoError > *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mem__ScopedCopyablePtrT_six__sicd__AntennaParameters_t = {"_p_mem__ScopedCopyablePtrT_six__sicd__AntennaParameters_t", "mem::ScopedCopyablePtr< six::sicd::AntennaParameters > *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mem__ScopedCopyablePtrT_six__sicd__Antenna_t = {"_p_mem__ScopedCopyablePtrT_six__sicd__Antenna_t", "mem::ScopedCopyablePtr< six::sicd::Antenna > *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_mem__ScopedCopyablePtrT_six__sicd__AreaDirectionParameters_t = {"_p_mem__ScopedCopyablePtrT_six__sicd__AreaDirectionParameters_t", "mem::ScopedCopyablePtr< six::sicd::AreaDirectionParameters > *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mem__ScopedCopyablePtrT_six__sicd__Distortion_t = {"_p_mem__ScopedCopyablePtrT_six__sicd__Distortion_t", "mem::ScopedCopyablePtr< six::sicd::Distortion > *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mem__ScopedCopyablePtrT_six__sicd__ElectricalBoresight_t = {"_p_mem__ScopedCopyablePtrT_six__sicd__ElectricalBoresight_t", "mem::ScopedCopyablePtr< six::sicd::ElectricalBoresight > *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mem__ScopedCopyablePtrT_six__sicd__GainAndPhasePolys_t = {"_p_mem__ScopedCopyablePtrT_six__sicd__GainAndPhasePolys_t", "mem::ScopedCopyablePtr< six::sicd::GainAndPhasePolys > *", 0, 0, (void*)0, 0}; @@ -131861,7 +133739,6 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_mem__ScopedCopyablePtrT_six__TropoError_t, &_swigt__p_mem__ScopedCopyablePtrT_six__sicd__AntennaParameters_t, &_swigt__p_mem__ScopedCopyablePtrT_six__sicd__Antenna_t, - &_swigt__p_mem__ScopedCopyablePtrT_six__sicd__AreaDirectionParameters_t, &_swigt__p_mem__ScopedCopyablePtrT_six__sicd__Distortion_t, &_swigt__p_mem__ScopedCopyablePtrT_six__sicd__ElectricalBoresight_t, &_swigt__p_mem__ScopedCopyablePtrT_six__sicd__GainAndPhasePolys_t, @@ -132083,7 +133960,6 @@ static swig_cast_info _swigc__p_mem__ScopedCopyablePtrT_six__Radiometric_t[] = { static swig_cast_info _swigc__p_mem__ScopedCopyablePtrT_six__TropoError_t[] = { {&_swigt__p_mem__ScopedCopyablePtrT_six__TropoError_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mem__ScopedCopyablePtrT_six__sicd__AntennaParameters_t[] = { {&_swigt__p_mem__ScopedCopyablePtrT_six__sicd__AntennaParameters_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mem__ScopedCopyablePtrT_six__sicd__Antenna_t[] = { {&_swigt__p_mem__ScopedCopyablePtrT_six__sicd__Antenna_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mem__ScopedCopyablePtrT_six__sicd__AreaDirectionParameters_t[] = { {&_swigt__p_mem__ScopedCopyablePtrT_six__sicd__AreaDirectionParameters_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mem__ScopedCopyablePtrT_six__sicd__Distortion_t[] = { {&_swigt__p_mem__ScopedCopyablePtrT_six__sicd__Distortion_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mem__ScopedCopyablePtrT_six__sicd__ElectricalBoresight_t[] = { {&_swigt__p_mem__ScopedCopyablePtrT_six__sicd__ElectricalBoresight_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mem__ScopedCopyablePtrT_six__sicd__GainAndPhasePolys_t[] = { {&_swigt__p_mem__ScopedCopyablePtrT_six__sicd__GainAndPhasePolys_t, 0, 0, 0},{0, 0, 0, 0}}; @@ -132305,7 +134181,6 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_mem__ScopedCopyablePtrT_six__TropoError_t, _swigc__p_mem__ScopedCopyablePtrT_six__sicd__AntennaParameters_t, _swigc__p_mem__ScopedCopyablePtrT_six__sicd__Antenna_t, - _swigc__p_mem__ScopedCopyablePtrT_six__sicd__AreaDirectionParameters_t, _swigc__p_mem__ScopedCopyablePtrT_six__sicd__Distortion_t, _swigc__p_mem__ScopedCopyablePtrT_six__sicd__ElectricalBoresight_t, _swigc__p_mem__ScopedCopyablePtrT_six__sicd__GainAndPhasePolys_t, diff --git a/modules/python/six.sicd/source/six_sicd.i b/modules/python/six.sicd/source/six_sicd.i index 1a03bfaac..11a76b054 100644 --- a/modules/python/six.sicd/source/six_sicd.i +++ b/modules/python/six.sicd/source/six_sicd.i @@ -137,7 +137,9 @@ six::sicd::ComplexData * asComplexData(six::Data* data); %template(VectorPolyXYZ) std::vector; -%template(ScopedCloneableAreaDirectionParameters) mem::ScopedCopyablePtr; +%template(ScopedCloneableDirectionParameters) mem::ScopedCloneablePtr; + +%template(ScopedCloneableAreaDirectionParameters) mem::ScopedCloneablePtr; %template(ScopedCloneableSegment) mem::ScopedCloneablePtr; %template(ScopedCloneableTxStep) mem::ScopedCloneablePtr; %template(ScopedCloneableWaveformParameters) mem::ScopedCloneablePtr;