1 2 %feature("director") OpenSim::AnalysisWrapper; 3 %feature("director") OpenSim::SimtkLogCallback; 4 %feature("notabstract") ControlLinear; 5 6 %rename(OpenSimObject) OpenSim::Object; 7 %rename(OpenSimException) OpenSim::Exception; 8 9 // osimCommon Library 10 %include <OpenSim/Common/osimCommonDLL.h> 11 %include <OpenSim/Common/About.h> 12 %include <OpenSim/Common/Exception.h> 13 %include <OpenSim/Common/Array.h> 14 %include <OpenSim/Common/ArrayPtrs.h> 15 %include <OpenSim/Common/AbstractProperty.h> 16 %ignore OpenSim::Property<std::string>::appendValue(std::string const *); 17 %include <OpenSim/Common/Property.h> 18 %include <OpenSim/Common/PropertyGroup.h> 19 %template(ArrayPtrsPropertyGroup) OpenSim::ArrayPtrs<OpenSim::PropertyGroup>; 20 %template (PropertyString) OpenSim::Property<std::string>; 21 %include <OpenSim/Common/Object.h> 22 %include <OpenSim/Common/ObjectGroup.h> 23 24 %include <OpenSim/Common/Set.h> 25 %template(OpenSimObjectSet) OpenSim::Set<OpenSim::Object, OpenSim::Object>; 26 %include <OpenSim/Common/StateVector.h> 27 %template(ArrayStateVector) OpenSim::Array<OpenSim::StateVector>; 28 %include <OpenSim/Common/StorageInterface.h> 29 %include <OpenSim/Common/Storage.h> 30 %template(ArrayStorage) OpenSim::ArrayPtrs<OpenSim::Storage>; 31 %include <OpenSim/Common/Units.h> 32 %include <OpenSim/Common/IO.h> 33 %include <OpenSim/Common/Function.h> 34 35 %template(SetFunctions) OpenSim::Set<OpenSim::Function, OpenSim::Object>; 36 %include <OpenSim/Common/FunctionSet.h> 37 38 %include <OpenSim/Common/Constant.h> 39 %include <OpenSim/Common/SimmSpline.h> 40 %include <OpenSim/Common/StepFunction.h> 41 %include <OpenSim/Common/PiecewiseConstantFunction.h> 42 %include <OpenSim/Common/LinearFunction.h> 43 %include <OpenSim/Common/PiecewiseLinearFunction.h> 44 %include <OpenSim/Common/MultiplierFunction.h> 45 %include <OpenSim/Common/GCVSpline.h> 46 %include <OpenSim/Common/Sine.h> 47 %include <OpenSim/Common/PolynomialFunction.h> 48 49 %include <OpenSim/Common/SmoothSegmentedFunctionFactory.h> 50 %include <OpenSim/Common/SmoothSegmentedFunction.h> 51 52 %include <OpenSim/Common/XYFunctionInterface.h> 53 %template(ArrayXYPoint) OpenSim::Array<XYPoint>; 54 %template(ArrayBool) OpenSim::Array<bool>; 55 %template(ArrayDouble) OpenSim::Array<double>; 56 %template(ArrayInt) OpenSim::Array<int>; 57 %template(ArrayStr) OpenSim::Array<std::string>; 58 %template(ArrayVec3) OpenSim::Array<SimTK::Vec3>; 59 %template(ArrayObjPtr) OpenSim::Array<OpenSim::Object*>; 60 %template(ArrayPtrsObj) OpenSim::ArrayPtrs<OpenSim::Object>; 61 %template(ArrayConstObjPtr) OpenSim::Array<const OpenSim::Object*>; 62 %template(ArrayPtrsConstObj) OpenSim::ArrayPtrs<const OpenSim::Object>; 63 64 namespace OpenSim { 65 %ignore LoadOpenSimLibraries; 66 } 67 %include <OpenSim/Common/LoadOpenSimLibrary.h> 68 69 // Used in Component::generateDecorations. 70 %include <OpenSim/Common/ModelDisplayHints.h> 71 72 namespace OpenSim { 73 %ignore Output::downcast(AbstractOutput&); // suppress warning 509. 74 } 75 // TODO I'm having trouble with the nested type inside a template class. 76 // TODO %template(OutputChannelDouble) OpenSim::Output<double>::Channel; 77 // TODO %template(OutputChannelVec3) OpenSim::Output<SimTK::Vec3>::Channel; 78 // TODO %template(OutputChannelTransform) OpenSim::Output<SimTK::Transform>::Channel; 79 // TODO %template(OutputChannelVector) OpenSim::Output<SimTK::Vector>::Channel; 80 %include <OpenSim/Common/ComponentOutput.h> 81 %template(OutputDouble) OpenSim::Output<double>; 82 %template(OutputVec3) OpenSim::Output<SimTK::Vec3>; 83 %template(OutputTransform) OpenSim::Output<SimTK::Transform>; 84 %template(OutputVector) OpenSim::Output<SimTK::Vector>; 85 %template(OutputSpatialVec) OpenSim::Output<SimTK::SpatialVec>; 86 87 namespace OpenSim { 88 %ignore Input::downcast(AbstractInput&); // suppress warning 509. 89 } 90 %include <OpenSim/Common/ComponentSocket.h> 91 %template(InputDouble) OpenSim::Input<double>; 92 %template(InputVec3) OpenSim::Input<SimTK::Vec3>; 93 // TODO These classes had issues from SimTK typedefs: 94 // TODO %template(InputTransform) OpenSim::Input<SimTK::Transform>; 95 // TODO %template(InputVector) OpenSim::Input<SimTK::Vector>; 96 97 namespace OpenSim { 98 %ignore ComponentListIterator::operator++; // ignore warning 383. 99 } 100 %include <OpenSim/Common/ComponentList.h> 101 102 // Can't wrap the return type of this function. 103 %ignore OpenSim::Component::getOutputs; 104 105 %include <OpenSim/Common/Path.h> 106 %include <OpenSim/Common/ComponentPath.h> 107 108 %include <OpenSim/Common/Component.h> 109 %template(findComponent) OpenSim::Component::findComponent<OpenSim::Component>; 110 111 %template(ComponentsList) OpenSim::ComponentList<const OpenSim::Component>; 112 %template(ComponentIterator) OpenSim::ComponentListIterator<const OpenSim::Component>; 113 %template(getComponentsList) OpenSim::Component::getComponentList<OpenSim::Component>; 114 115 116 %include <OpenSim/Common/Scale.h> 117 %template(SetScales) OpenSim::Set<OpenSim::Scale, OpenSim::Object>; 118 %include <OpenSim/Common/ScaleSet.h> 119 %include <OpenSim/Common/MarkerFrame.h> 120 %include <OpenSim/Common/MarkerData.h> 121 122 %shared_ptr(OpenSim::AbstractDataTable); 123 %shared_ptr(OpenSim::DataTable_<double, double>); 124 %shared_ptr(OpenSim::DataTable_<double, SimTK::Vec3>); 125 %shared_ptr(OpenSim::DataTable_<double, SimTK::UnitVec3>); 126 %shared_ptr(OpenSim::DataTable_<double, SimTK::Quaternion_<double>>); 127 %shared_ptr(OpenSim::DataTable_<double, SimTK::Vec6>); 128 %shared_ptr(OpenSim::DataTable_<double, SimTK::SpatialVec>); 129 %shared_ptr(OpenSim::DataTable_<double, SimTK::Mat33>); 130 %shared_ptr(OpenSim::DataTable_<double, SimTK::Rotation_<double>>); 131 %shared_ptr(OpenSim::TimeSeriesTable_<double>); 132 %shared_ptr(OpenSim::TimeSeriesTable_<SimTK::Vec3>); 133 %shared_ptr(OpenSim::TimeSeriesTable_<SimTK::UnitVec3>); 134 %shared_ptr(OpenSim::TimeSeriesTable_<SimTK::Quaternion_<double>>); 135 %shared_ptr(OpenSim::TimeSeriesTable_<SimTK::Vec6>); 136 %shared_ptr(OpenSim::TimeSeriesTable_<SimTK::SpatialVec>); 137 %shared_ptr(OpenSim::TimeSeriesTable_<SimTK::Mat33>); 138 %shared_ptr(OpenSim::TimeSeriesTable_<SimTK::Rotation_<double>>); 139 %ignore OpenSim::AbstractDataTable::clone; 140 %ignore OpenSim::AbstractDataTable::getTableMetaData; 141 %ignore OpenSim::AbstractDataTable::updTableMetaData; 142 %ignore OpenSim::AbstractDataTable::getIndependentMetaData; 143 %ignore OpenSim::AbstractDataTable::setIndependentMetaData; 144 %ignore OpenSim::AbstractDataTable::getDependentsMetaData; 145 %ignore OpenSim::AbstractDataTable::setDependentsMetaData; 146 %ignore OpenSim::AbstractDataTable::setColumnLabels( 147 const std::initializer_list<std::string>&); 148 %template(StdVectorMatrix) std::vector<SimTK::Matrix_<double>>; 149 %extend OpenSim::AbstractDataTable { setColumnLabels(const std::vector<std::string> & columnLabels)150 void setColumnLabels(const std::vector<std::string>& columnLabels) { 151 $self->setColumnLabels(columnLabels); 152 } 153 addTableMetaDataString(const std::string & key,const std::string & value)154 void addTableMetaDataString(const std::string& key, 155 const std::string& value) { 156 $self->addTableMetaData<std::string>(key, value); 157 } 158 159 std::vector<SimTK::Matrix_<double>> getTableMetaDataVectorMatrix(const std::string & key)160 getTableMetaDataVectorMatrix(const std::string& key) const { 161 return 162 $self->getTableMetaData<std::vector<SimTK::Matrix_<double>>>(key); 163 } 164 165 std::vector<unsigned> getTableMetaDataVectorUnsigned(const std::string & key)166 getTableMetaDataVectorUnsigned(const std::string& key) const { 167 return $self->getTableMetaData<std::vector<unsigned>>(key); 168 } 169 170 std::string getTableMetaDataString(const std::string & key)171 getTableMetaDataString(const std::string& key) const { 172 return $self->getTableMetaData<std::string>(key); 173 } 174 175 std::vector<std::string> getDependentsMetaDataString(const std::string & key)176 getDependentsMetaDataString(const std::string& key) const { 177 const auto& depMetaData = $self->getDependentsMetaData(); 178 const auto& absValArray = depMetaData.getValueArrayForKey(key); 179 const auto& values = 180 (dynamic_cast<const ValueArray<std::string>&>(absValArray)).get(); 181 std::vector<std::string> metadata{}; 182 for(const auto& val : values) 183 metadata.push_back(val.get()); 184 return metadata; 185 } 186 } 187 %ignore OpenSim::DataTable_::DataTable_(DataTable_ &&); 188 %ignore OpenSim::DataTable_::DataTable_(const DataTable_<double, double>&, 189 const std::vector<std::string>&); 190 %ignore OpenSim::DataTable_<double, double>::flatten; 191 // A version of SWIG between 3.0.6 and 3.0.12 broke the ability to extend class 192 // templates with more than 1 template parameter, so we must enumerate the 193 // possible template arguments (not necesary for TimeSeriesTable's clone; that 194 // template has only 1 param.). 195 //%extend OpenSim::DataTable_ { 196 // OpenSim::DataTable_<ETX, ETY>* clone() const { 197 // return new OpenSim::DataTable_<ETX, ETY>{*$self}; 198 // } 199 //} 200 %define DATATABLE_CLONE(ETX, ETY) 201 %extend OpenSim::DataTable_<ETX, ETY> { clone()202 OpenSim::DataTable_<ETX, ETY>* clone() const { 203 return new OpenSim::DataTable_<ETX, ETY>{*$self}; 204 } 205 } 206 %enddef 207 DATATABLE_CLONE(double, double) 208 DATATABLE_CLONE(double, SimTK::Vec3) 209 DATATABLE_CLONE(double, SimTK::UnitVec3) 210 DATATABLE_CLONE(double, SimTK::Quaternion_<double>) 211 DATATABLE_CLONE(double, SimTK::Vec6) 212 DATATABLE_CLONE(double, SimTK::SpatialVec) 213 DATATABLE_CLONE(double, SimTK::Rotation_<double>) 214 %extend OpenSim::DataTable_<double, double> { 215 DataTable_<double, SimTK::Vec3> packVec3()216 packVec3() { 217 return $self->pack<SimTK::Vec3>(); 218 } 219 DataTable_<double, SimTK::Vec3> packVec3(std::vector<std::string> suffixes)220 packVec3(std::vector<std::string> suffixes) { 221 return $self->pack<SimTK::Vec3>(); 222 } 223 DataTable_<double, SimTK::UnitVec3> packUnitVec3()224 packUnitVec3() { 225 return $self->pack<SimTK::UnitVec3>(); 226 } 227 DataTable_<double, SimTK::UnitVec3> packUnitVec3(std::vector<std::string> suffixes)228 packUnitVec3(std::vector<std::string> suffixes) { 229 return $self->pack<SimTK::UnitVec3>(); 230 } 231 DataTable_<double, SimTK::Quaternion_<double>> packQuaternion()232 packQuaternion() { 233 return $self->pack<SimTK::Quaternion>(); 234 } 235 DataTable_<double, SimTK::Quaternion_<double>> packQuaternion(std::vector<std::string> suffixes)236 packQuaternion(std::vector<std::string> suffixes) { 237 return $self->pack<SimTK::Quaternion>(); 238 } 239 DataTable_<double, SimTK::SpatialVec> packSpatialVec()240 packSpatialVec() { 241 return $self->pack<SimTK::SpatialVec>(); 242 } 243 DataTable_<double, SimTK::SpatialVec> packSpatialVec(std::vector<std::string> suffixes)244 packSpatialVec(std::vector<std::string> suffixes) { 245 return $self->pack<SimTK::SpatialVec>(); 246 } 247 } 248 249 %ignore OpenSim::TimeSeriesTable_::TimeSeriesTable_(TimeSeriesTable_ &&); 250 %extend OpenSim::TimeSeriesTable_ { clone()251 OpenSim::TimeSeriesTable_<ETY>* clone() const { 252 return new OpenSim::TimeSeriesTable_<ETY>{*$self}; 253 } 254 } 255 %extend OpenSim::TimeSeriesTable_<double> { 256 TimeSeriesTable_<SimTK::Vec3> packVec3()257 packVec3() { 258 return $self->pack<SimTK::Vec3>(); 259 } 260 TimeSeriesTable_<SimTK::Vec3> packVec3(std::vector<std::string> suffixes)261 packVec3(std::vector<std::string> suffixes) { 262 return $self->pack<SimTK::Vec3>(); 263 } 264 TimeSeriesTable_<SimTK::UnitVec3> packUnitVec3()265 packUnitVec3() { 266 return $self->pack<SimTK::UnitVec3>(); 267 } 268 TimeSeriesTable_<SimTK::UnitVec3> packUnitVec3(std::vector<std::string> suffixes)269 packUnitVec3(std::vector<std::string> suffixes) { 270 return $self->pack<SimTK::UnitVec3>(); 271 } 272 TimeSeriesTable_<SimTK::Quaternion_<double>> packQuaternion()273 packQuaternion() { 274 return $self->pack<SimTK::Quaternion>(); 275 } 276 TimeSeriesTable_<SimTK::Quaternion_<double>> packQuaternion(std::vector<std::string> suffixes)277 packQuaternion(std::vector<std::string> suffixes) { 278 return $self->pack<SimTK::Quaternion>(); 279 } 280 TimeSeriesTable_<SimTK::SpatialVec> packSpatialVec()281 packSpatialVec() { 282 return $self->pack<SimTK::SpatialVec>(); 283 } 284 TimeSeriesTable_<SimTK::SpatialVec> packSpatialVec(std::vector<std::string> suffixes)285 packSpatialVec(std::vector<std::string> suffixes) { 286 return $self->pack<SimTK::SpatialVec>(); 287 } 288 } 289 %extend OpenSim::TimeSeriesTable_<SimTK::Vec3> { flatten()290 TimeSeriesTable_<double> flatten() { 291 return $self->flatten(); 292 } flatten(std::vector<std::string> suffixes)293 TimeSeriesTable_<double> flatten(std::vector<std::string> suffixes) { 294 return $self->flatten(suffixes); 295 } 296 } 297 %extend OpenSim::TimeSeriesTable_<SimTK::UnitVec3> { flatten()298 TimeSeriesTable_<double> flatten() { 299 return $self->flatten(); 300 } flatten(std::vector<std::string> suffixes)301 TimeSeriesTable_<double> flatten(std::vector<std::string> suffixes) { 302 return $self->flatten(suffixes); 303 } 304 } 305 %extend OpenSim::TimeSeriesTable_<SimTK::Quaternion> { flatten()306 TimeSeriesTable_<double> flatten() { 307 return $self->flatten(); 308 } flatten(std::vector<std::string> suffixes)309 TimeSeriesTable_<double> flatten(std::vector<std::string> suffixes) { 310 return $self->flatten(suffixes); 311 } 312 } 313 %extend OpenSim::TimeSeriesTable_<SimTK::Vec6> { flatten()314 TimeSeriesTable_<double> flatten() { 315 return $self->flatten(); 316 } flatten(std::vector<std::string> suffixes)317 TimeSeriesTable_<double> flatten(std::vector<std::string> suffixes) { 318 return $self->flatten(suffixes); 319 } 320 } 321 %extend OpenSim::TimeSeriesTable_<SimTK::SpatialVec> { flatten()322 TimeSeriesTable_<double> flatten() { 323 return $self->flatten(); 324 } flatten(std::vector<std::string> suffixes)325 TimeSeriesTable_<double> flatten(std::vector<std::string> suffixes) { 326 return $self->flatten(suffixes); 327 } 328 } 329 330 %include <OpenSim/Common/AbstractDataTable.h> 331 %include <OpenSim/Common/DataTable.h> 332 %include <OpenSim/Common/TimeSeriesTable.h> 333 334 %template(DataTable) OpenSim::DataTable_<double, double>; 335 %template(DataTableVec3) OpenSim::DataTable_<double, SimTK::Vec3>; 336 %template(DataTableUnitVec3) OpenSim::DataTable_<double, SimTK::UnitVec3>; 337 %template(DataTableQuaternion) OpenSim::DataTable_<double, SimTK::Quaternion_<double>>; 338 %template(DataTableVec6) OpenSim::DataTable_<double, SimTK::Vec6>; 339 %template(DataTableSpatialVec) OpenSim::DataTable_<double, SimTK::SpatialVec>; 340 %template(DataTableMat33) OpenSim::DataTable_<double, SimTK::Mat33>; 341 %template(DataTableRotation) OpenSim::DataTable_<double, SimTK::Rotation_<double>>; 342 343 %template(TimeSeriesTable) OpenSim::TimeSeriesTable_<double>; 344 %template(TimeSeriesTableVec3) OpenSim::TimeSeriesTable_<SimTK::Vec3>; 345 %template(TimeSeriesTableUnitVec3) OpenSim::TimeSeriesTable_<SimTK::UnitVec3>; 346 %template(TimeSeriesTableQuaternion) 347 OpenSim::TimeSeriesTable_<SimTK::Quaternion_<double>>; 348 %template(TimeSeriesTableVec6) OpenSim::TimeSeriesTable_<SimTK::Vec6>; 349 %template(TimeSeriesTableSpatialVec) 350 OpenSim::TimeSeriesTable_<SimTK::SpatialVec>; 351 %template(TimeSeriesTableMat33) OpenSim::TimeSeriesTable_<SimTK::Mat33>; 352 %template(TimeSeriesTableRotation) OpenSim::TimeSeriesTable_<SimTK::Rotation_<double>>; 353 354 %include <OpenSim/Common/Event.h> 355 %template(StdVectorEvent) std::vector<OpenSim::Event>; 356 /* 357 %template(StdMapStringTimeSeriesTableVec3) 358 std::map<std::string, 359 std::shared_ptr<OpenSim::TimeSeriesTable_<SimTK::Vec3>>>; 360 */ 361 %shared_ptr(OpenSim::DataAdapter) 362 %shared_ptr(OpenSim::FileAdapter) 363 %shared_ptr(OpenSim::DelimFileAdapter) 364 %shared_ptr(OpenSim::IMUDataReader) 365 %shared_ptr(OpenSim::XsensDataReader) 366 %shared_ptr(OpenSim::APDMDataReader) 367 %shared_ptr(OpenSim::STOFileAdapter_<duoble>) 368 %shared_ptr(OpenSim::STOFileAdapter_<SimTK::Vec3>) 369 %shared_ptr(OpenSim::STOFileAdapter_<SimTK::UnitVec3>) 370 %shared_ptr(OpenSim::STOFileAdapter_<SimTK::Quaternion>) 371 %shared_ptr(OpenSim::STOFileAdapter_<SimTK::Vec6>) 372 %shared_ptr(OpenSim::STOFileAdapter_<SimTK::SpatialVec>) 373 %shared_ptr(OpenSim::CSVFileAdapter) 374 %shared_ptr(OpenSim::TRCFileAdapter) 375 %shared_ptr(OpenSim::C3DFileAdapter) 376 %template(StdMapStringDataAdapter) 377 std::map<std::string, std::shared_ptr<OpenSim::DataAdapter>>; 378 %template(StdMapStringAbstractDataTable) 379 std::map<std::string, std::shared_ptr<OpenSim::AbstractDataTable>>; 380 %include <OpenSim/Common/DataAdapter.h> 381 %include <OpenSim/Common/ExperimentalSensor.h> 382 %include <OpenSim/Common/IMUDataReader.h> 383 %include <OpenSim/Common/XsensDataReaderSettings.h> 384 %include <OpenSim/Common/XsensDataReader.h> 385 386 387 %include <OpenSim/Common/FileAdapter.h> 388 namespace OpenSim { 389 %ignore TRCFileAdapter::TRCFileAdapter(TRCFileAdapter &&); 390 %ignore DelimFileAdapter::DelimFileAdapter(DelimFileAdapter &&); 391 %ignore CSVFileAdapter::CSVFileAdapter(CSVFileAdapter &&); 392 } 393 %include <OpenSim/Common/TRCFileAdapter.h> 394 %include <OpenSim/Common/DelimFileAdapter.h> 395 %include <OpenSim/Common/APDMDataReaderSettings.h> 396 %include <OpenSim/Common/APDMDataReader.h> 397 %ignore OpenSim::createSTOFileAdapterForReading; 398 %ignore OpenSim::createSTOFileAdapterForWriting; 399 %ignore OpenSim::STOFileAdapter_::STOFileAdapter_(STOFileAdapter_&&); 400 %include <OpenSim/Common/STOFileAdapter.h> 401 %template(STOFileAdapter) OpenSim::STOFileAdapter_<double>; 402 %template(STOFileAdapterVec3) OpenSim::STOFileAdapter_<SimTK::Vec3>; 403 %template(STOFileAdapterUnitVec3) OpenSim::STOFileAdapter_<SimTK::UnitVec3>; 404 %template(STOFileAdapterQuaternion) OpenSim::STOFileAdapter_<SimTK::Quaternion>; 405 %template(STOFileAdapterVec6) OpenSim::STOFileAdapter_<SimTK::Vec6>; 406 %template(STOFileAdapterSpatialVec) OpenSim::STOFileAdapter_<SimTK::SpatialVec>; 407 408 %include <OpenSim/Common/CSVFileAdapter.h> 409 %include <OpenSim/Common/XsensDataReader.h> 410 %include <OpenSim/Common/C3DFileAdapter.h> 411 412 %extend OpenSim::C3DFileAdapter { setLocationForForceExpression(unsigned int wrt)413 void setLocationForForceExpression(unsigned int wrt) { 414 C3DFileAdapter::ForceLocation location; 415 switch(wrt) { 416 case 0: 417 location = C3DFileAdapter::ForceLocation::OriginOfForcePlate; 418 break; 419 case 1: 420 location = C3DFileAdapter::ForceLocation::CenterOfPressure; 421 break; 422 case 2: 423 location = C3DFileAdapter::ForceLocation::PointOfWrenchApplication; 424 break; 425 default: 426 throw OpenSim::Exception{ 427 "An invalid C3DFileAdapter::ForceLocation was provided."}; 428 } 429 $self->setLocationForForceExpression(location); 430 }; 431 }; 432 433 namespace OpenSim { 434 %ignore TableSource_::TableSource_(TableSource_ &&); 435 } 436 %include <OpenSim/Common/TableSource.h> 437 %template(TableSource) OpenSim::TableSource_<SimTK::Real>; 438 %template(TableSourceVec3) OpenSim::TableSource_<SimTK::Vec3>; 439 440 %include <OpenSim/Common/Reporter.h> 441 %template(ReporterDouble) OpenSim::Reporter<SimTK::Real>; 442 %template(ReporterVec3) OpenSim::Reporter<SimTK::Vec3>; 443 %template(ReporterVector) OpenSim::Reporter<SimTK::Vector>; 444 %template(TableReporter) OpenSim::TableReporter_<SimTK::Real>; 445 %template(TableReporterVec3) OpenSim::TableReporter_<SimTK::Vec3>; 446 %template(TableReporterSpatialVec) OpenSim::TableReporter_<SimTK::SpatialVec>; 447 %template(TableReporterVector) OpenSim::TableReporter_<SimTK::Vector, SimTK::Real>; 448 %template(ConsoleReporter) OpenSim::ConsoleReporter_<SimTK::Real>; 449 %template(ConsoleReporterVec3) OpenSim::ConsoleReporter_<SimTK::Vec3>; 450 451 %include <OpenSim/Common/GCVSplineSet.h> 452 453 454 // Compensate for insufficient C++11 support in SWIG 455 // ================================================= 456 /* 457 Extend concrete Sets to use the inherited base constructors. 458 This is only necessary because SWIG does not generate these inherited 459 constructors provided by C++11's 'using' (e.g. using Set::Set) declaration. 460 Note that CustomJoint and EllipsoidJoint do implement their own 461 constructors because they have additional arguments. 462 */ 463 %define EXPOSE_SET_CONSTRUCTORS_HELPER(NAME) 464 %extend OpenSim::NAME { NAME()465 NAME() { 466 return new NAME(); 467 } throw(OpenSim::Exception)468 NAME(const std::string& file, bool updateFromXML=true) throw(OpenSim::Exception) { 469 return new NAME(file, updateFromXML); 470 } 471 }; 472 %enddef 473