JointModelRevoluteTpl<NewScalar,Options,axis> cast() const { typedef JointModelRevoluteTpl<NewScalar,Options,axis> ReturnType; ReturnType res; res.setIndexes(id(),idx_q(),idx_v()); return res; }
JointModelPlanarTpl<NewScalar,Options> cast() const { typedef JointModelPlanarTpl<NewScalar,Options> ReturnType; ReturnType res; res.setIndexes(id(),idx_q(),idx_v()); return res; }
ReturnType operator()(Vcf::Entry const& entry) const { auto rawvs = Vcf::RawVariant::processEntry(entry); ReturnType rv; for (auto i = rawvs.begin(); i != rawvs.end(); ++i) { // if we set the region begin to the region end then // we would be reporting only the start position. // that is a useful option sometimes. rv.insert(i->region()); } // For ref-only entries: if (rawvs.empty()) { Region reg{entry.start(), entry.stop()}; rv.insert(reg); } return rv; }
std::vector<std::list<Parameterization> > ParameterizedCommand::ExpandParameters( unsigned int startIndex, const std::vector<IParameter::Pointer>& parameters) { typedef std::vector<std::list<Parameterization> > ReturnType; const unsigned int nextIndex = startIndex + 1; const bool noMoreParameters = (nextIndex >= parameters.size()); const IParameter::Pointer parameter(parameters[startIndex]); ReturnType parameterizations; if (parameter->IsOptional()) { parameterizations.push_back(std::list<Parameterization>()); } IParameter::ParameterValues parameterValues(parameter->GetValues()); for (IParameter::ParameterValues::iterator parameterValueItr = parameterValues.begin(); parameterValueItr != parameterValues.end(); ++parameterValueItr) { std::list<Parameterization> combination; combination.push_back( Parameterization(parameter, parameterValueItr->second)); parameterizations.push_back(combination); } // Check if another iteration will produce any more names. if (noMoreParameters) { // This is it, so just return the current parameterizations. return parameterizations; } // Make recursive call ReturnType suffixes(ExpandParameters(nextIndex, parameters)); if (suffixes.empty()) { // This is it, so just return the current parameterizations. return parameterizations; } ReturnType returnValue; for (ReturnType::iterator suffixItr = suffixes.begin(); suffixItr != suffixes.end(); ++suffixItr) { for (ReturnType::iterator combinationItr = parameterizations.begin(); combinationItr != parameterizations.end(); ++combinationItr) { std::list<Parameterization> newCombination(*combinationItr); newCombination.insert(newCombination.end(), suffixItr->begin(), suffixItr->end()); returnValue.push_back(newCombination); } } return returnValue; }
typename internal::SE3GroupAction<TransformRevoluteTpl>::ReturnType se3action(const SE3Tpl<S2,O2> & m) const { typedef typename internal::SE3GroupAction<TransformRevoluteTpl>::ReturnType ReturnType; ReturnType res; switch(axis) { case 0: { res.rotation().col(0) = m.rotation().col(0); res.rotation().col(1).noalias() = m_cos * m.rotation().col(1) + m_sin * m.rotation().col(2); res.rotation().col(2).noalias() = res.rotation().col(0).cross(res.rotation().col(1)); break; } case 1: { res.rotation().col(1) = m.rotation().col(1); res.rotation().col(2).noalias() = m_cos * m.rotation().col(2) + m_sin * m.rotation().col(0); res.rotation().col(0).noalias() = res.rotation().col(1).cross(res.rotation().col(2)); break; } case 2: { res.rotation().col(2) = m.rotation().col(2); res.rotation().col(0).noalias() = m_cos * m.rotation().col(0) + m_sin * m.rotation().col(1); res.rotation().col(1).noalias() = res.rotation().col(2).cross(res.rotation().col(0)); break; } default: { assert(false && "must nerver happened"); break; } } res.translation() = m.translation(); return res; }
uniform_kernel(GeneratorType *g, ReturnType a, ReturnType b) : g(*g), d_real(a.real(), b.real()), d_imag(a.imag(), b.imag()) {}
static const std::string to(const ReturnType& source) {return source.string();}
QList<QList<Parameterization> > ParameterizedCommand::ExpandParameters( unsigned int startIndex, const QList<IParameter::Pointer>& parameters) { typedef QList<QList<Parameterization> > ReturnType; const int nextIndex = startIndex + 1; const bool noMoreParameters = (nextIndex >= parameters.size()); const IParameter::Pointer parameter(parameters[startIndex]); ReturnType parameterizations; if (parameter->IsOptional()) { parameterizations.push_back(QList<Parameterization>()); } IParameterValues* values = NULL; try { values = parameter->GetValues(); } catch (const ParameterValuesException& /*e*/) { if (noMoreParameters) { return parameterizations; } // Make recursive call return ExpandParameters(nextIndex, parameters); } const QHash<QString,QString> parameterValues = values->GetParameterValues(); for (IParameter::ParameterValues::const_iterator parameterValueItr = parameterValues.begin(); parameterValueItr != parameterValues.end(); ++parameterValueItr) { QList<Parameterization> combination; combination.push_back( Parameterization(parameter, parameterValueItr.value())); parameterizations.push_back(combination); } // Check if another iteration will produce any more names. if (noMoreParameters) { // This is it, so just return the current parameterizations. return parameterizations; } // Make recursive call ReturnType suffixes(ExpandParameters(nextIndex, parameters)); if (suffixes.empty()) { // This is it, so just return the current parameterizations. return parameterizations; } ReturnType returnValue; for (ReturnType::iterator suffixItr = suffixes.begin(); suffixItr != suffixes.end(); ++suffixItr) { for (ReturnType::iterator combinationItr = parameterizations.begin(); combinationItr != parameterizations.end(); ++combinationItr) { QList<Parameterization> newCombination(*combinationItr); newCombination.append(*suffixItr); returnValue.push_back(newCombination); } } return returnValue; }