Reference guide

Class Inheritance diagram

openalea.lpy.gui.simulation module

class openalea.lpy.__lpy_kernel__.ArgList

Bases: instance

append((ArgList)arg1, (object)arg2) → None :

C++ signature :

void append(std::deque<boost::python::api::object, std::allocator<boost::python::api::object> > {lvalue},boost::python::api::object)

extend((ArgList)arg1, (object)arg2) → None :

C++ signature :

void extend(std::deque<boost::python::api::object, std::allocator<boost::python::api::object> > {lvalue},boost::python::api::object)

class openalea.lpy.__lpy_kernel__.AxialTree

Bases: instance

append((AxialTree)arg1, (ParamModule)arg2) → None :

C++ signature :

void append(LPY::AxialTree {lvalue},LPY::ParamModule)

append( (AxialTree)arg1, (AxialTree)arg2) -> None :

C++ signature :

void append(LPY::AxialTree {lvalue},LPY::AxialTree)

append( (AxialTree)arg1, (str)arg2) -> None :

C++ signature :

void append(LPY::AxialTree*,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

argSize((AxialTree)arg1) → int :

C++ signature :

unsigned long argSize(LPY::AxialTree {lvalue})

beginBracket((AxialTree)arg1, (object)arg2[, (object)startingAfterPos=False]) → object :

C++ signature :

boost::python::api::object beginBracket(LPY::AxialTree*,int [,bool=False])

children((AxialTree)arg1, (object)pos[, (ConsiderFilter)filter=None]) → object :

C++ signature :

boost::python::api::object children(LPY::AxialTree*,int [,LPY::ConsiderFilter*=None])

children( (AxialTree)arg1, (object)pos, (str)edge_type [, (ConsiderFilter)filter=None]) -> object :

C++ signature :

boost::python::api::object children(LPY::AxialTree*,int,char [,LPY::ConsiderFilter*=None])

clear((AxialTree)arg1) → None :

C++ signature :

void clear(LPY::AxialTree {lvalue})

complex((AxialTree)arg1, (object)arg2, (object)pos[, (ConsiderFilter)filter=None]) → object :

C++ signature :

boost::python::api::object complex(LPY::AxialTree*,int,int [,LPY::ConsiderFilter*=None])

complex( (AxialTree)pos, (object)scale [, (ConsiderFilter)filter=None]) -> object :

C++ signature :

boost::python::api::object complex(LPY::AxialTree*,int [,LPY::ConsiderFilter*=None])

components((AxialTree)arg1, (object)pos[, (ConsiderFilter)filter=None]) → object :

C++ signature :

boost::python::api::object components(LPY::AxialTree*,int [,LPY::ConsiderFilter*=None])

components_at_scale((AxialTree)arg1, (object)pos, (object)scale[, (ConsiderFilter)filter=None]) → object :

C++ signature :

boost::python::api::object components_at_scale(LPY::AxialTree*,int,int [,LPY::ConsiderFilter*=None])

count((AxialTree)arg1, (str)arg2) → int :

C++ signature :

unsigned long count(LPY::AxialTree {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

count( (AxialTree)arg1, (str)arg2, (object)arg3) -> int :

C++ signature :

unsigned long count(LPY::AxialTree {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >,unsigned long)

count( (AxialTree)arg1, (ParamModule)arg2) -> int :

C++ signature :

unsigned long count(LPY::AxialTree {lvalue},LPY::ParamModule)

directSon(**kwargs)

deprecated function. See direct_child

direct_child((AxialTree)arg1, (object)pos[, (ConsiderFilter)filter=None]) → object :

C++ signature :

boost::python::api::object direct_child(LPY::AxialTree*,int [,LPY::ConsiderFilter*=None])

empty((AxialTree)arg1) → bool :

C++ signature :

bool empty(LPY::AxialTree {lvalue})

endBracket((AxialTree)arg1, (object)arg2[, (object)startingBeforePos=False]) → object :

C++ signature :

boost::python::api::object endBracket(LPY::AxialTree*,int [,bool=False])

father(**kwargs)

deprecated function. See parent

find((AxialTree)arg1, (PatternModule)pattern[, (object)start=0[, (object)end=2147483647]]) → object :

C++ signature :

boost::python::api::object find(LPY::AxialTree*,LPY::PatternModule [,int=0 [,int=2147483647]])

find( (AxialTree)arg1, (str)pattern [, (object)start=0 [, (object)end=2147483647]]) -> object :

C++ signature :

boost::python::api::object find(LPY::AxialTree*,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > [,int=0 [,int=2147483647]])

hasRequestModule((AxialTree)arg1) → bool :

C++ signature :

bool hasRequestModule(LPY::AxialTree {lvalue})

insertAt((AxialTree)arg1, (object)arg2, (ParamModule)arg3) → None :

C++ signature :

void insertAt(LPY::AxialTree {lvalue},int,LPY::ParamModule)

insertAt( (AxialTree)arg1, (object)arg2, (AxialTree)arg3) -> None :

C++ signature :

void insertAt(LPY::AxialTree {lvalue},int,LPY::AxialTree)

insertAt( (AxialTree)arg1, (object)arg2, (str)arg3) -> None :

C++ signature :

void insertAt(LPY::AxialTree*,int,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

insertAt( (AxialTree)arg1, (object)arg2, (tuple)arg3) -> None :

C++ signature :

void insertAt(LPY::AxialTree*,int,boost::python::tuple)

isAPath((AxialTree)arg1) → bool :

C++ signature :

bool isAPath(LPY::AxialTree {lvalue})

lateralSons(**kwargs)

deprecated function. See lateral_children

lateral_children((AxialTree)arg1, (object)pos[, (ConsiderFilter)filter=None]) → object :

C++ signature :

boost::python::api::object lateral_children(LPY::AxialTree*,int [,LPY::ConsiderFilter*=None])

leftmatch((AxialTree)arg1, (PatternString)arg2, (object)arg3) → bool :

C++ signature :

bool leftmatch(LPY::AxialTree*,LPY::PatternString,int)

leftmatch( (AxialTree)arg1, (PatternModule)arg2, (object)arg3) -> bool :

C++ signature :

bool leftmatch(LPY::AxialTree*,LPY::PatternModule,int)

leftmatch( (AxialTree)arg1, (str)arg2, (object)arg3) -> bool :

C++ signature :

bool leftmatch(LPY::AxialTree*,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >,int)

match((AxialTree)arg1, (PatternString)arg2, (object)arg3) → bool :

C++ signature :

bool match(LPY::AxialTree*,LPY::PatternString,int)

match( (AxialTree)arg1, (PatternModule)arg2, (object)arg3) -> bool :

C++ signature :

bool match(LPY::AxialTree*,LPY::PatternModule,int)

match( (AxialTree)arg1, (str)arg2, (object)arg3) -> bool :

C++ signature :

bool match(LPY::AxialTree*,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >,int)

node((AxialTree)arg1, (object)arg2) → NodeModule :

C++ signature :

LPY::NodeModule node(LPY::AxialTree*,int)

parent((AxialTree)arg1, (object)pos[, (ConsiderFilter)filter=None]) → object :

C++ signature :

boost::python::api::object parent(LPY::AxialTree*,int [,LPY::ConsiderFilter*=None])

predecessor_at_level((AxialTree)arg1, (object)pos, (object)level[, (ConsiderFilter)filter=None]) → object :

C++ signature :

boost::python::api::object predecessor_at_level(LPY::AxialTree*,int,int [,LPY::ConsiderFilter*=None])

predecessor_at_scale((AxialTree)arg1, (object)pos, (object)scale[, (ConsiderFilter)filter=None]) → object :

C++ signature :

boost::python::api::object predecessor_at_scale(LPY::AxialTree*,int,int [,LPY::ConsiderFilter*=None])

prepend((AxialTree)arg1, (ParamModule)arg2) → None :

C++ signature :

void prepend(LPY::AxialTree {lvalue},LPY::ParamModule)

prepend( (AxialTree)arg1, (AxialTree)arg2) -> None :

C++ signature :

void prepend(LPY::AxialTree {lvalue},LPY::AxialTree)

prepend( (AxialTree)arg1, (str)arg2) -> None :

C++ signature :

void prepend(LPY::AxialTree*,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

replace((AxialTree)arg1, (object)arg2, (object)arg3) → AxialTree :

C++ signature :

LPY::AxialTree replace(LPY::AxialTree*,boost::python::api::object,boost::python::api::object)

reverse_match((AxialTree)arg1, (PatternString)arg2, (object)arg3) → bool :

C++ signature :

bool reverse_match(LPY::AxialTree*,LPY::PatternString,int)

reverse_match( (AxialTree)arg1, (PatternModule)arg2, (object)arg3) -> bool :

C++ signature :

bool reverse_match(LPY::AxialTree*,LPY::PatternModule,int)

reverse_match( (AxialTree)arg1, (str)arg2, (object)arg3) -> bool :

C++ signature :

bool reverse_match(LPY::AxialTree*,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >,int)

rightmatch((AxialTree)arg1, (PatternString)arg2, (object)arg3) → bool :

C++ signature :

bool rightmatch(LPY::AxialTree*,LPY::PatternString,int)

rightmatch( (AxialTree)arg1, (PatternModule)arg2, (object)arg3) -> bool :

C++ signature :

bool rightmatch(LPY::AxialTree*,LPY::PatternModule,int)

rightmatch( (AxialTree)arg1, (str)arg2, (object)arg3) -> bool :

C++ signature :

bool rightmatch(LPY::AxialTree*,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >,int)

roots((AxialTree)arg1[, (ConsiderFilter)filter=None]) → object :

C++ signature :

boost::python::api::object roots(LPY::AxialTree* [,LPY::ConsiderFilter*=None])

sons(**kwargs)

deprecated function. See children

str_slice((AxialTree)arg1, (object)arg2, (object)arg3) → str :

C++ signature :

std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > str_slice(LPY::AxialTree {lvalue},int,int)

successor_at_level((AxialTree)arg1, (object)pos, (object)level[, (ConsiderFilter)filter=None]) → object :

C++ signature :

boost::python::api::object successor_at_level(LPY::AxialTree*,int,int [,LPY::ConsiderFilter*=None])

successor_at_scale((AxialTree)arg1, (object)pos, (object)scale[, (ConsiderFilter)filter=None]) → object :

C++ signature :

boost::python::api::object successor_at_scale(LPY::AxialTree*,int,int [,LPY::ConsiderFilter*=None])

wellBracketed((AxialTree)arg1) → bool :

C++ signature :

bool wellBracketed(LPY::AxialTree {lvalue})

class openalea.lpy.__lpy_kernel__.AxialTreeIterator

Bases: instance

current((AxialTreeIterator)arg1) → ParamModule :

C++ signature :

LPY::ParamModule current(LPY::PyLstringIterator<LPY::AxialTree, std::_Deque_iterator<LPY::ParamModule, LPY::ParamModule const&, LPY::ParamModule const*> > {lvalue})

next((AxialTreeIterator)arg1[, (object)onlyConsidered=False]) → ParamModule :

C++ signature :

LPY::ParamModule next(LPY::PyLstringIterator<LPY::AxialTree, std::_Deque_iterator<LPY::ParamModule, LPY::ParamModule const&, LPY::ParamModule const*> > {lvalue} [,bool=False])

toEndBracket((AxialTreeIterator)arg1[, (object)startingBeforePos=False]) → ParamModule :

C++ signature :

LPY::ParamModule toEndBracket(LPY::PyLstringIterator<LPY::AxialTree, std::_Deque_iterator<LPY::ParamModule, LPY::ParamModule const&, LPY::ParamModule const*> > {lvalue} [,bool=False])

class openalea.lpy.__lpy_kernel__.ConsiderFilter

Bases: instance

Filter on the module to consider in the context of the rules

static consider((str)arg1) → ConsiderFilter :

C++ signature :

PGL::RefCountPtr<LPY::ConsiderFilter> consider(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

static ignore((str)arg1) → ConsiderFilter :

C++ signature :

PGL::RefCountPtr<LPY::ConsiderFilter> ignore(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

static ignorePredefined() → ConsiderFilter :

C++ signature :

PGL::RefCountPtr<LPY::ConsiderFilter> ignorePredefined()

ignoring((ConsiderFilter)arg1) → bool :

C++ signature :

bool ignoring(LPY::ConsiderFilter {lvalue})

isConsidered((ConsiderFilter)arg1, (str)arg2) → bool :

C++ signature :

bool isConsidered(LPY::ConsiderFilter {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

isConsidered( (ConsiderFilter)arg1, (Module)arg2) -> bool :

C++ signature :

bool isConsidered(LPY::ConsiderFilter {lvalue},LPY::Module)

isConsidered( (ConsiderFilter)arg1, (ModuleClass)arg2) -> bool :

C++ signature :

bool isConsidered(LPY::ConsiderFilter {lvalue},PGL::RefCountPtr<LPY::ModuleClass>)

isIgnored((ConsiderFilter)arg1, (str)arg2) → bool :

C++ signature :

bool isIgnored(LPY::ConsiderFilter {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

isIgnored( (ConsiderFilter)arg1, (Module)arg2) -> bool :

C++ signature :

bool isIgnored(LPY::ConsiderFilter {lvalue},LPY::Module)

isIgnored( (ConsiderFilter)arg1, (ModuleClass)arg2) -> bool :

C++ signature :

bool isIgnored(LPY::ConsiderFilter {lvalue},PGL::RefCountPtr<LPY::ModuleClass>)

keyword((ConsiderFilter)arg1) → str :

C++ signature :

std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > keyword(LPY::ConsiderFilter {lvalue})

str((ConsiderFilter)arg1) → str :

C++ signature :

std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > str(LPY::ConsiderFilter {lvalue})

class openalea.lpy.__lpy_kernel__.LpyDebugger

Bases: instance

property alwaysStop

begin((LpyDebugger)arg1, (AxialTree)arg2, (eDirection)arg3) → None :

C++ signature :

void begin(LPY::Lsystem::Debugger {lvalue},LPY::AxialTree,LPY::eDirection)

begin( (LpyDebugger)arg1, (AxialTree)arg2, (eDirection)arg3) -> None :

C++ signature :

void begin(PyLpyDebugger {lvalue},LPY::AxialTree,LPY::eDirection)

clearBreakPoints((LpyDebugger)arg1) → None :

C++ signature :

void clearBreakPoints(LPY::Lsystem::Debugger {lvalue})

clearCodeBreakPoints((LpyDebugger)arg1) → None :

C++ signature :

void clearCodeBreakPoints(LPY::Lsystem::Debugger {lvalue})

clearLstringBreakPoints((LpyDebugger)arg1) → None :

C++ signature :

void clearLstringBreakPoints(LPY::Lsystem::Debugger {lvalue})

clearPyError((LpyDebugger)arg1) → None :

C++ signature :

void clearPyError(PyLpyDebugger {lvalue})

end((LpyDebugger)arg1, (AxialTree)arg2) → None :

C++ signature :

void end(LPY::Lsystem::Debugger {lvalue},LPY::AxialTree)

end( (LpyDebugger)arg1, (AxialTree)arg2) -> None :

C++ signature :

void end(PyLpyDebugger {lvalue},LPY::AxialTree)

error_match((LpyDebugger)arg1, (object)arg2, (object)arg3, (AxialTree)arg4, (LsysRule)arg5, (ArgList)arg6) → bool :

C++ signature :

bool error_match(LPY::Lsystem::Debugger {lvalue},std::_Deque_iterator<LPY::ParamModule, LPY::ParamModule const&, LPY::ParamModule const*>,std::_Deque_iterator<LPY::ParamModule, LPY::ParamModule const&, LPY::ParamModule const*>,LPY::AxialTree,LPY::LsysRule const*,std::deque<boost::python::api::object, std::allocator<boost::python::api::object> >)

error_match( (LpyDebugger)arg1, (object)arg2, (object)arg3, (AxialTree)arg4, (LsysRule)arg5, (ArgList)arg6) -> bool :

C++ signature :

bool error_match(PyLpyDebugger {lvalue},std::_Deque_iterator<LPY::ParamModule, LPY::ParamModule const&, LPY::ParamModule const*>,std::_Deque_iterator<LPY::ParamModule, LPY::ParamModule const&, LPY::ParamModule const*>,LPY::AxialTree,LPY::LsysRule const*,std::deque<boost::python::api::object, std::allocator<boost::python::api::object> >)

hasCodeBreakPointAt((LpyDebugger)arg1, (object)arg2) → bool :

C++ signature :

bool hasCodeBreakPointAt(LPY::Lsystem::Debugger {lvalue},unsigned int)

hasLstringBreakPointAt((LpyDebugger)arg1, (object)arg2) → None :

C++ signature :

void hasLstringBreakPointAt(PyLpyDebugger {lvalue},unsigned int)

identity((LpyDebugger)arg1, (object)arg2, (AxialTree)arg3) → None :

C++ signature :

void identity(LPY::Lsystem::Debugger {lvalue},std::_Deque_iterator<LPY::ParamModule, LPY::ParamModule const&, LPY::ParamModule const*>,LPY::AxialTree)

identity( (LpyDebugger)arg1, (object)arg2, (AxialTree)arg3) -> None :

C++ signature :

void identity(PyLpyDebugger {lvalue},std::_Deque_iterator<LPY::ParamModule, LPY::ParamModule const&, LPY::ParamModule const*>,LPY::AxialTree)

insertCodeBreakPointAt((LpyDebugger)arg1, (object)arg2) → None :

C++ signature :

void insertCodeBreakPointAt(LPY::Lsystem::Debugger {lvalue},unsigned int)

insertLstringBreakPointAt((LpyDebugger)arg1, (object)arg2) → None :

C++ signature :

void insertLstringBreakPointAt(PyLpyDebugger {lvalue},unsigned int)

partial_match((LpyDebugger)arg1, (object)arg2, (object)arg3, (AxialTree)arg4, (LsysRule)arg5, (ArgList)arg6) → None :

C++ signature :

void partial_match(LPY::Lsystem::Debugger {lvalue},std::_Deque_iterator<LPY::ParamModule, LPY::ParamModule const&, LPY::ParamModule const*>,std::_Deque_iterator<LPY::ParamModule, LPY::ParamModule const&, LPY::ParamModule const*>,LPY::AxialTree,LPY::LsysRule const*,std::deque<boost::python::api::object, std::allocator<boost::python::api::object> >)

partial_match( (LpyDebugger)arg1, (object)arg2, (object)arg3, (AxialTree)arg4, (LsysRule)arg5, (ArgList)arg6) -> None :

C++ signature :

void partial_match(PyLpyDebugger {lvalue},std::_Deque_iterator<LPY::ParamModule, LPY::ParamModule const&, LPY::ParamModule const*>,std::_Deque_iterator<LPY::ParamModule, LPY::ParamModule const&, LPY::ParamModule const*>,LPY::AxialTree,LPY::LsysRule const*,std::deque<boost::python::api::object, std::allocator<boost::python::api::object> >)

removeCodeBreakPointAt((LpyDebugger)arg1, (object)arg2) → None :

C++ signature :

void removeCodeBreakPointAt(LPY::Lsystem::Debugger {lvalue},unsigned int)

removeLstringBreakPointAt((LpyDebugger)arg1, (object)arg2) → None :

C++ signature :

void removeLstringBreakPointAt(PyLpyDebugger {lvalue},unsigned int)

total_match((LpyDebugger)arg1, (object)arg2, (object)arg3, (AxialTree)arg4, (object)arg5, (LsysRule)arg6, (ArgList)arg7) → None :

C++ signature :

void total_match(LPY::Lsystem::Debugger {lvalue},std::_Deque_iterator<LPY::ParamModule, LPY::ParamModule const&, LPY::ParamModule const*>,std::_Deque_iterator<LPY::ParamModule, LPY::ParamModule const&, LPY::ParamModule const*>,LPY::AxialTree,unsigned long,LPY::LsysRule const*,std::deque<boost::python::api::object, std::allocator<boost::python::api::object> >)

total_match( (LpyDebugger)arg1, (object)arg2, (object)arg3, (AxialTree)arg4, (object)arg5, (LsysRule)arg6, (ArgList)arg7) -> None :

C++ signature :

void total_match(PyLpyDebugger {lvalue},std::_Deque_iterator<LPY::ParamModule, LPY::ParamModule const&, LPY::ParamModule const*>,std::_Deque_iterator<LPY::ParamModule, LPY::ParamModule const&, LPY::ParamModule const*>,LPY::AxialTree,unsigned long,LPY::LsysRule const*,std::deque<boost::python::api::object, std::allocator<boost::python::api::object> >)

class openalea.lpy.__lpy_kernel__.LpyParsing

Bases: instance

DefaultFormat = 1.0

InitialisationBeginTag = '###### INITIALISATION ######'

VersionTag = '# -*- lpy version: %f -*-'

formats = [1.0]

static getFormatVersion((str)arg1) → float :

C++ signature :

float getFormatVersion(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

static isFormatDefined((str)arg1) → bool :

C++ signature :

bool isFormatDefined(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

static isSupportedFormat((object)arg1) → bool :

C++ signature :

bool isSupportedFormat(float)

static lstring2py((str)arg1) → str :

C++ signature :

std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > lstring2py(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

class openalea.lpy.__lpy_kernel__.LsysContext

Bases: instance

Lsystem Execution Context

InitialisationFunctionName = '__initialiseContext__'

property animation_timestep

backward((LsysContext)arg1) → None :

C++ signature :

void backward(LPY::LsysContext {lvalue})

clear((LsysContext)arg1) → None :

C++ signature :

void clear(LPY::LsysContext {lvalue})

clearNamespace((LsysContext)arg1) → None :

C++ signature :

void clearNamespace(LPY::LsysContext {lvalue})

compile((LsysContext)arg1, (str)arg2) → None :

C++ signature :

void compile(LPY::LsysContext {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

compile( (LsysContext)arg1, (str)arg2, (str)arg3) -> object :

C++ signature :

boost::python::api::object compile(LPY::LsysContext {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

static current() → LsysContext :

C++ signature :

LPY::LsysContext* current()

static currentContext() → LsysContext :

C++ signature :

LPY::LsysContext* currentContext()

declare((LsysContext)arg1, (str)arg2) → None :

C++ signature :

void declare(LPY::LsysContext {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

declaredModules((LsysContext)arg1) → object :

C++ signature :

boost::python::api::object declaredModules(LPY::LsysContext*)

static default() → LsysContext :

C++ signature :

LPY::LsysContext* default()

static defaultContext() → LsysContext :

C++ signature :

LPY::LsysContext* defaultContext()

done((LsysContext)arg1) → None :

C++ signature :

void done(LPY::LsysContext {lvalue})

empty((LsysContext)arg1) → bool :

C++ signature :

bool empty(LPY::LsysContext {lvalue})

end((LsysContext)arg1) → object :

C++ signature :

boost::python::api::object end(LPY::LsysContext {lvalue})

endEach((LsysContext)arg1) → object :

C++ signature :

boost::python::api::object endEach(LPY::LsysContext {lvalue})

evaluate((LsysContext)arg1, (str)arg2) → object :

C++ signature :

boost::python::api::object evaluate(LPY::LsysContext {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

forward((LsysContext)arg1) → None :

C++ signature :

void forward(LPY::LsysContext {lvalue})

frameDisplay((LsysContext)arg1[, (object)enabled=True]) → None :

C++ signature :

void frameDisplay(LPY::LsysContext {lvalue} [,bool=True])

get((LsysContext)arg1, (str)arg2, (object)arg3) → object :

C++ signature :

boost::python::api::object get(LPY::LsysContext {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >,boost::python::api::object)

getGroup((LsysContext)arg1) → int :

C++ signature :

unsigned long getGroup(LPY::LsysContext {lvalue})

getIterationNb((LsysContext)arg1) → int :

C++ signature :

unsigned long getIterationNb(LPY::LsysContext {lvalue})

getNamespace((LsysContext)arg1, (dict)arg2) → None :

C++ signature :

void getNamespace(LPY::LsysContext {lvalue},boost::python::dict {lvalue})

static globalContext() → LsysContext :

C++ signature :

LPY::LsysContext* globalContext()

globals((LsysContext)arg1) → object :

C++ signature :

boost::python::api::object globals(LPY::LsysContext*)

has_key((LsysContext)arg1, (str)arg2) → bool :

C++ signature :

bool has_key(LPY::LsysContext {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

initialise((LsysContext)arg1) → bool :

C++ signature :

bool initialise(LPY::LsysContext {lvalue})

initialiseFrom((LsysContext)arg1, (str)arg2) → object :

C++ signature :

boost::python::api::object initialiseFrom(LPY::LsysContext*,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

isAnimationEnabled((LsysContext)arg1) → bool :

C++ signature :

bool isAnimationEnabled(LPY::LsysContext {lvalue})

isCurrent((LsysContext)arg1) → bool :

C++ signature :

bool isCurrent(LPY::LsysContext {lvalue})

isDeclared((LsysContext)arg1, (str)arg2) → bool :

C++ signature :

bool isDeclared(LPY::LsysContext {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

isForward((LsysContext)arg1) → bool :

C++ signature :

bool isForward(LPY::LsysContext {lvalue})

isFrameDisplayed((LsysContext)arg1) → bool :

C++ signature :

bool isFrameDisplayed(LPY::LsysContext {lvalue})

isSelectionAlwaysRequired((LsysContext)arg1) → bool :

C++ signature :

bool isSelectionAlwaysRequired(LPY::LsysContext {lvalue})

is_animation_timestep_to_default((LsysContext)arg1) → bool :

C++ signature :

bool is_animation_timestep_to_default(LPY::LsysContext {lvalue})

locals((LsysContext)arg1) → dict :

C++ signature :

boost::python::dict locals(LPY::LsysContext {lvalue})

makeCurrent((LsysContext)arg1) → None :

C++ signature :

void makeCurrent(LPY::LsysContext {lvalue})

nproduce((LsysContext)arg1, (AxialTree)arg2) → None :

C++ signature :

void nproduce(LPY::LsysContext {lvalue},LPY::AxialTree)

nproduce( (LsysContext)arg1, (list)arg2) -> None :

C++ signature :

void nproduce(LPY::LsysContext {lvalue},boost::python::list)

property options

postDraw((LsysContext)arg1) → None :

C++ signature :

void postDraw(LPY::LsysContext {lvalue})

requestSelection((LsysContext)arg1, (str)message) → None :

C++ signature :

void requestSelection(LPY::LsysContext {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

setEnd((LsysContext)arg1, (object)arg2) → None :

C++ signature :

void setEnd(LPY::LsysContext {lvalue},boost::python::api::object)

setEndEach((LsysContext)arg1, (object)arg2) → None :

C++ signature :

void setEndEach(LPY::LsysContext {lvalue},boost::python::api::object)

setModuleScale((LsysContext)arg1, (str)arg2, (object)arg3) → None :

C++ signature :

void setModuleScale(LPY::LsysContext {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >,int)

setPostDraw((LsysContext)arg1, (object)arg2) → None :

C++ signature :

void setPostDraw(LPY::LsysContext {lvalue},boost::python::api::object)

setSelectionAlwaysRequired((LsysContext)arg1, (object)arg2) → None :

C++ signature :

void setSelectionAlwaysRequired(LPY::LsysContext {lvalue},bool)

setStart((LsysContext)arg1, (object)arg2) → None :

C++ signature :

void setStart(LPY::LsysContext {lvalue},boost::python::api::object)

setStartEach((LsysContext)arg1, (object)arg2) → None :

C++ signature :

void setStartEach(LPY::LsysContext {lvalue},boost::python::api::object)

start((LsysContext)arg1) → object :

C++ signature :

boost::python::api::object start(LPY::LsysContext {lvalue})

startEach((LsysContext)arg1) → object :

C++ signature :

boost::python::api::object startEach(LPY::LsysContext {lvalue})

stop((LsysContext)arg1) → None :

C++ signature :

void stop(LPY::LsysContext {lvalue})

property turtle

undeclare((LsysContext)arg1, (str)arg2) → None :

C++ signature :

void undeclare(LPY::LsysContext {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

updateNamespace((LsysContext)arg1, (dict)arg2) → None :

C++ signature :

void updateNamespace(LPY::LsysContext {lvalue},boost::python::dict {lvalue})

useGroup((LsysContext)arg1, (object)arg2) → None :

C++ signature :

void useGroup(LPY::LsysContext {lvalue},unsigned long)

class openalea.lpy.__lpy_kernel__.LsysOption

Bases: instance

activate((LsysOption)arg1, (str)value) → bool :

C++ signature :

bool activate(LPY::LsysOption {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

activateSelection((LsysOption)arg1) → bool :

C++ signature :

bool activateSelection(LPY::LsysOption {lvalue})

property category

property comment

currentValue((LsysOption)arg1) → str :

C++ signature :

std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > currentValue(LPY::LsysOption {lvalue})

property default_value_id

property global

isToDefault((LsysOption)arg1) → bool :

C++ signature :

bool isToDefault(LPY::LsysOption {lvalue})

property name

property selection

setSelection((LsysOption)arg1, (str)arg2) → bool :

C++ signature :

bool setSelection(LPY::LsysOption {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

setSelection( (LsysOption)arg1, (object)arg2) -> bool :

C++ signature :

bool setSelection(LPY::LsysOption {lvalue},unsigned long)

class openalea.lpy.__lpy_kernel__.LsysOptionValue

Bases: instance

activate((LsysOptionValue)arg1) → None :

C++ signature :

void activate(LPY::LsysOptionValue {lvalue})

property comment

property name

class openalea.lpy.__lpy_kernel__.LsysOptions

Bases: instance

activate((LsysOptions)arg1, (str)arg2, (str)value) → bool :

C++ signature :

bool activate(LPY::LsysOptions {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

activateSelection((LsysOptions)arg1, (str)arg2) → bool :

C++ signature :

bool activateSelection(LPY::LsysOptions {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

find((LsysOptions)arg1, (str)arg2) → LsysOption :

C++ signature :

LPY::LsysOption* find(LPY::LsysOptions {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

setSelection((LsysOptions)arg1, (str)arg2, (str)arg3) → bool :

C++ signature :

bool setSelection(LPY::LsysOptions {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

setSelection( (LsysOptions)arg1, (str)arg2, (object)arg3) -> bool :

C++ signature :

bool setSelection(LPY::LsysOptions {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >,unsigned long)

class openalea.lpy.__lpy_kernel__.LsysRule

Bases: instance

applyTo((LsysRule)arg1, (AxialTree)arg2, (ArgList)arg3) → bool :

C++ signature :

bool applyTo(LPY::LsysRule*,LPY::AxialTree {lvalue},std::deque<boost::python::api::object, std::allocator<boost::python::api::object> >)

backwardCompatible((LsysRule)arg1) → bool :

C++ signature :

bool backwardCompatible(LPY::LsysRule {lvalue})

clear((LsysRule)arg1) → None :

C++ signature :

void clear(LPY::LsysRule {lvalue})

code((LsysRule)arg1) → str :

C++ signature :

std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > code(LPY::LsysRule {lvalue})

property codelength

compile((LsysRule)arg1) → None :

C++ signature :

void compile(LPY::LsysRule {lvalue})

compile( (LsysRule)arg1, (dict)arg2) -> None :

C++ signature :

void compile(LPY::LsysRule {lvalue},boost::python::dict {lvalue})

consider((LsysRule)arg1, (str)arg2) → None :

C++ signature :

void consider(LPY::LsysRule {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

consider( (LsysRule)arg1, (ConsiderFilter)arg2) -> None :

C++ signature :

void consider(LPY::LsysRule {lvalue},PGL::RefCountPtr<LPY::ConsiderFilter>)

property considerFilter

definition((LsysRule)arg1) → object :

C++ signature :

std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > definition(LPY::LsysRule {lvalue})

forwardCompatible((LsysRule)arg1) → bool :

C++ signature :

bool forwardCompatible(LPY::LsysRule {lvalue})

function((LsysRule)arg1) → object :

C++ signature :

boost::python::api::object function(LPY::LsysRule {lvalue})

functionName((LsysRule)arg1) → str :

C++ signature :

std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > functionName(LPY::LsysRule {lvalue})

property groupId

hasQuery((LsysRule)arg1) → bool :

C++ signature :

bool hasQuery(LPY::LsysRule {lvalue})

property id

ignore((LsysRule)arg1, (str)arg2) → None :

C++ signature :

void ignore(LPY::LsysRule {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

isCompiled((LsysRule)arg1) → bool :

C++ signature :

bool isCompiled(LPY::LsysRule {lvalue})

isContextFree((LsysRule)arg1) → bool :

C++ signature :

bool isContextFree(LPY::LsysRule {lvalue})

leftContext((LsysRule)arg1) → PatternString :

C++ signature :

LPY::PatternString leftContext(LPY::LsysRule {lvalue})

property lineno

match((LsysRule)arg1, (AxialTree)arg2[, (object)arg3[, (AxialTree)arg4]]) → object :

C++ signature :

boost::python::api::object match(LPY::LsysRule*,LPY::AxialTree [,int [,LPY::AxialTree]])

name((LsysRule)arg1) → str :

C++ signature :

std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > name(LPY::LsysRule {lvalue})

nbContexts((LsysRule)arg1) → int :

C++ signature :

unsigned long nbContexts(LPY::LsysRule {lvalue})

nbParameters((LsysRule)arg1) → int :

C++ signature :

unsigned long nbParameters(LPY::LsysRule {lvalue})

newLeftContext((LsysRule)arg1) → PatternString :

C++ signature :

LPY::PatternString newLeftContext(LPY::LsysRule {lvalue})

newRightContext((LsysRule)arg1) → PatternString :

C++ signature :

LPY::PatternString newRightContext(LPY::LsysRule {lvalue})

parameterNames((LsysRule)arg1) → object :

C++ signature :

boost::python::api::object parameterNames(LPY::LsysRule*)

predecessor((LsysRule)arg1) → PatternString :

C++ signature :

LPY::PatternString predecessor(LPY::LsysRule {lvalue})

process((LsysRule)arg1, (AxialTree)arg2) → AxialTree :

C++ signature :

LPY::AxialTree process(LPY::LsysRule {lvalue},LPY::AxialTree)

recompile((LsysRule)arg1) → None :

C++ signature :

void recompile(LPY::LsysRule {lvalue})

reverse_match((LsysRule)arg1, (AxialTree)arg2[, (object)arg3[, (AxialTree)arg4]]) → object :

C++ signature :

boost::python::api::object reverse_match(LPY::LsysRule*,LPY::AxialTree [,int [,LPY::AxialTree {lvalue}]])

rightContext((LsysRule)arg1) → PatternString :

C++ signature :

LPY::PatternString rightContext(LPY::LsysRule {lvalue})

set((LsysRule)arg1, (str)arg2) → None :

C++ signature :

void set(LPY::LsysRule*,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

property static

class openalea.lpy.__lpy_kernel__.LsysVar

Bases: instance

isArgs((LsysVar)arg1) → bool :

C++ signature :

bool isArgs(LPY::LsysVar {lvalue})

isKwds((LsysVar)arg1) → bool :

C++ signature :

bool isKwds(LPY::LsysVar {lvalue})

property name

value((LsysVar)arg1) → object :

C++ signature :

boost::python::api::object value(LPY::LsysVar*)

varname((LsysVar)arg1) → str :

C++ signature :

std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > varname(LPY::LsysVar {lvalue})

class openalea.lpy.__lpy_kernel__.Lsystem

Bases: instance

addDecompositionRule((Lsystem)arg1, (str)code[, (object)group=0[, (ConsiderFilter)filter=None]]) → None :

Add Decomposition rule

C++ signature :

void addDecompositionRule(LPY::Lsystem {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > [,unsigned long=0 [,PGL::RefCountPtr<LPY::ConsiderFilter>=None]])

addInterpretationRule((Lsystem)arg1, (str)code[, (object)group=0[, (ConsiderFilter)filter=None]]) → None :

Add Interpretation rule

C++ signature :

void addInterpretationRule(LPY::Lsystem {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > [,unsigned long=0 [,PGL::RefCountPtr<LPY::ConsiderFilter>=None]])

addProductionRule((Lsystem)arg1, (str)code[, (object)group=0[, (ConsiderFilter)filter=None]]) → None :

Add Production rule

C++ signature :

void addProductionRule(LPY::Lsystem {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > [,unsigned long=0 [,PGL::RefCountPtr<LPY::ConsiderFilter>=None]])

addRule((Lsystem)arg1, (str)code[, (object)ruletype=openalea.lpy.__lpy_kernel__.eRuleType.eProduction[, (object)group=0[, (ConsiderFilter)filter=None]]]) → None :

Add a rule

C++ signature :

void addRule(LPY::Lsystem {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > [,int=openalea.lpy.__lpy_kernel__.eRuleType.eProduction [,unsigned long=0 [,PGL::RefCountPtr<LPY::ConsiderFilter>=None]]])

addRule( (Lsystem)arg1, (LsysRule)rule [, (object)ruletype=openalea.lpy.__lpy_kernel__.eRuleType.eProduction [, (object)group=0]]) -> None :

Add a rule

C++ signature :

void addRule(LPY::Lsystem {lvalue},LPY::LsysRule [,int=openalea.lpy.__lpy_kernel__.eRuleType.eProduction [,unsigned long=0]])

animate((Lsystem)arg1) → AxialTree :

C++ signature :

LPY::AxialTree animate(LPY::Lsystem {lvalue})

animate( (Lsystem)arg1, (object)arg2) -> AxialTree :

C++ signature :

LPY::AxialTree animate(LPY::Lsystem {lvalue},double)

animate( (Lsystem)arg1, (object)arg2, (object)arg3) -> AxialTree :

C++ signature :

LPY::AxialTree animate(LPY::Lsystem {lvalue},double,unsigned long)

animate( (Lsystem)arg1, (object)arg2, (object)arg3, (object)arg4) -> AxialTree :

C++ signature :

LPY::AxialTree animate(LPY::Lsystem {lvalue},double,unsigned long,unsigned long)

animate( (Lsystem)arg1, (AxialTree)arg2, (object)arg3, (object)arg4, (object)arg5) -> AxialTree :

C++ signature :

LPY::AxialTree animate(LPY::Lsystem {lvalue},LPY::AxialTree,double,unsigned long,unsigned long)

property axiom

clear((Lsystem)arg1) → None :

C++ signature :

void clear(LPY::Lsystem {lvalue})

clearDebugger((Lsystem)arg1) → None :

C++ signature :

void clearDebugger(LPY::Lsystem {lvalue})

code((Lsystem)arg1) → str :

C++ signature :

std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > code(LPY::Lsystem {lvalue})

compile((Lsystem)arg1) → None :

C++ signature :

void compile(LPY::Lsystem {lvalue})

context((Lsystem)arg1) → LsysContext :

Return execution context of the L-system. See also execContext.

C++ signature :

LPY::LsysContext* context(LPY::Lsystem {lvalue})

property decompositionMaxDepth

decompositionRule((Lsystem)arg1[, (object)ruleid=0[, (object)group=0]]) → LsysRule :

C++ signature :

LPY::LsysRule decompositionRule(LPY::Lsystem* [,int=0 [,int=0]])

property derivationLength

derivations(nbiterations) → LsystemIterator

derivations(start, nbiterations[, step]) → LsystemIterator

Return an iterator that produces a sequence of Lstring from the Lsystem from start (inclusive) to stop (inclusive) by step.

derive((Lsystem)arg1) → AxialTree :

C++ signature :

LPY::AxialTree derive(LPY::Lsystem {lvalue})

derive( (Lsystem)arg1, (object)arg2) -> AxialTree :

C++ signature :

LPY::AxialTree derive(LPY::Lsystem {lvalue},unsigned long)

derive( (Lsystem)arg1, (AxialTree)arg2) -> AxialTree :

C++ signature :

LPY::AxialTree derive(LPY::Lsystem {lvalue},LPY::AxialTree)

derive( (Lsystem)arg1, (AxialTree)arg2, (object)arg3) -> AxialTree :

C++ signature :

LPY::AxialTree derive(LPY::Lsystem {lvalue},LPY::AxialTree,unsigned long)

derive( (Lsystem)arg1, (AxialTree)workstring, (object)starting_iter, (object)nb_iter [, (object)previouslyinterpreted=False]) -> AxialTree :

C++ signature :

LPY::AxialTree derive(LPY::Lsystem {lvalue},LPY::AxialTree,unsigned long,unsigned long [,bool=False])

done((Lsystem)arg1) → None :

C++ signature :

void done(LPY::Lsystem {lvalue})

property early_return

empty((Lsystem)arg1) → bool :

C++ signature :

bool empty(LPY::Lsystem {lvalue})

execContext((Lsystem)arg1) → LsysContext :

Return the execution context of the L-system.

C++ signature :

LPY::LsysContext* execContext(LPY::Lsystem {lvalue})

property filename

forceRelease((Lsystem)arg1) → None :

Force release of running state in case of violent ending. Not recommended. Use with care.

C++ signature :

void forceRelease(LPY::Lsystem {lvalue})

getDebugger((Lsystem)arg1) → object :

C++ signature :

PGL::RefCountPtr<LPY::Lsystem::Debugger> getDebugger(LPY::Lsystem {lvalue})

getLastComputedScene((Lsystem)arg1) → Scene :

C++ signature :

PGL::RefCountPtr<PGL::Scene> getLastComputedScene(LPY::Lsystem {lvalue})

getLastIterationNb((Lsystem)arg1) → int :

C++ signature :

unsigned long getLastIterationNb(LPY::Lsystem {lvalue})

get_rule_fonction_table((Lsystem)arg1) → object :

C++ signature :

boost::python::api::object get_rule_fonction_table(LPY::Lsystem const*)

hasDebugger((Lsystem)arg1) → bool :

C++ signature :

bool hasDebugger(LPY::Lsystem {lvalue})

homomorphism()

interpret( (Lsystem)arg1, (AxialTree)arg2) -> AxialTree :

Apply interpretation rule and gives the resulting string.

C++ signature :

LPY::AxialTree interpret(LPY::Lsystem {lvalue},LPY::AxialTree {lvalue})

interpret((Lsystem)arg1, (AxialTree)arg2) → AxialTree :

Apply interpretation rule and gives the resulting string.

C++ signature :

LPY::AxialTree interpret(LPY::Lsystem {lvalue},LPY::AxialTree {lvalue})

property interpretationMaxDepth

interpretationRule((Lsystem)arg1[, (object)ruleid=0[, (object)group=0]]) → LsysRule :

C++ signature :

LPY::LsysRule interpretationRule(LPY::Lsystem* [,int=0 [,int=0]])

isCompiled((Lsystem)arg1) → bool :

C++ signature :

bool isCompiled(LPY::Lsystem {lvalue})

isCurrent((Lsystem)arg1) → bool :

C++ signature :

bool isCurrent(LPY::Lsystem {lvalue})

isRunning((Lsystem)arg1) → bool :

Tell whether self is performing an action

C++ signature :

bool isRunning(LPY::Lsystem {lvalue})

iterate()

derive( (Lsystem)arg1) -> AxialTree :

C++ signature :

LPY::AxialTree derive(LPY::Lsystem {lvalue})

derive( (Lsystem)arg1, (object)arg2) -> AxialTree :

C++ signature :

LPY::AxialTree derive(LPY::Lsystem {lvalue},unsigned long)

derive( (Lsystem)arg1, (AxialTree)arg2) -> AxialTree :

C++ signature :

LPY::AxialTree derive(LPY::Lsystem {lvalue},LPY::AxialTree)

derive( (Lsystem)arg1, (AxialTree)arg2, (object)arg3) -> AxialTree :

C++ signature :

LPY::AxialTree derive(LPY::Lsystem {lvalue},LPY::AxialTree,unsigned long)

derive( (Lsystem)arg1, (AxialTree)workstring, (object)starting_iter, (object)nb_iter [, (object)previouslyinterpreted=False]) -> AxialTree :

C++ signature :

LPY::AxialTree derive(LPY::Lsystem {lvalue},LPY::AxialTree,unsigned long,unsigned long [,bool=False])

makeCurrent((Lsystem)arg1) → None :

C++ signature :

void makeCurrent(LPY::Lsystem {lvalue})

nbDecompositionRules((Lsystem)arg1[, (object)group=0]) → int :

C++ signature :

unsigned long nbDecompositionRules(LPY::Lsystem {lvalue} [,unsigned long=0])

nbGroups((Lsystem)arg1) → int :

Return number of groups

C++ signature :

unsigned long nbGroups(LPY::Lsystem {lvalue})

nbInterpretationRules((Lsystem)arg1[, (object)group=0]) → int :

C++ signature :

unsigned long nbInterpretationRules(LPY::Lsystem {lvalue} [,unsigned long=0])

nbProductionRules((Lsystem)arg1[, (object)group=0]) → int :

C++ signature :

unsigned long nbProductionRules(LPY::Lsystem {lvalue} [,unsigned long=0])

nbTotalRules((Lsystem)arg1) → int :

Return total number of rules considering all groups

C++ signature :

unsigned long nbTotalRules(LPY::Lsystem {lvalue})

partial_derivation((Lsystem)arg1, (AxialTree)workstring, (object)starting_position, (object)length) → AxialTree :

C++ signature :

LPY::AxialTree partial_derivation(LPY::Lsystem {lvalue},LPY::AxialTree {lvalue},unsigned long,unsigned long)

plot((Lsystem)arg1, (AxialTree)lstring[, (object)checkLastComputedScene=False]) → None :

Apply interpretation with execContext().turtle and plot the resulting scene. If checkLastComputedScene, check whether during last iteration a scene was computed. If yes reuse it.

C++ signature :

void plot(LPY::Lsystem {lvalue},LPY::AxialTree {lvalue} [,bool=False])

productionRule((Lsystem)arg1[, (object)ruleid=0[, (object)group=0]]) → LsysRule :

C++ signature :

LPY::LsysRule productionRule(LPY::Lsystem* [,int=0 [,int=0]])

read((Lsystem)arg1, (str)filename[, (dict)parameters={}]) → None :

Read the content of a file and execute it

C++ signature :

void read(LPY::Lsystem {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > [,boost::python::dict={}])

record((Lsystem)arg1, (str)prefix[, (str)suffix='png']) → None :

C++ signature :

void record(LPY::Lsystem {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > [,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >=’png’])

record( (Lsystem)arg1, (str)prefix, (object)nbiteration [, (str)suffix=’png’]) -> None :

C++ signature :

void record(LPY::Lsystem {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >,unsigned long [,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >=’png’])

record( (Lsystem)arg1, (str)prefix, (object)begin, (object)nbiteration [, (str)suffix=’png’]) -> None :

C++ signature :

void record(LPY::Lsystem {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >,unsigned long,unsigned long [,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >=’png’])

record( (Lsystem)arg1, (str)prefix, (AxialTree)workstring, (object)begin, (object)nbiteration [, (str)suffix=’png’]) -> None :

C++ signature :

void record(LPY::Lsystem {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >,LPY::AxialTree,unsigned long,unsigned long [,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >=’png’])

sceneInterpretation((Lsystem)arg1, (AxialTree)arg2) → Scene :

Apply interpretation with execContext().turtle and return resulting scene.

C++ signature :

PGL::RefCountPtr<PGL::Scene> sceneInterpretation(LPY::Lsystem {lvalue},LPY::AxialTree {lvalue})

set(**kwargs)

deprecated function. See setCode

setCode((Lsystem)arg1, (str)code[, (dict)parameters={}[, (object)debug=False]]) → object :

Set Lsystem code. If debug parameter is set to True, the translated Python code is returned.

C++ signature :

boost::python::api::object setCode(LPY::Lsystem*,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > [,boost::python::dict={} [,bool=False]])

setDebugger((Lsystem)arg1, (LpyDebugger)arg2) → None :

C++ signature :

void setDebugger(LPY::Lsystem*,LPY::Lsystem::Debugger*)

stepInterpretation((Lsystem)arg1, (AxialTree)arg2) → None :

Apply interpretation step by step and display construction of the scene.

C++ signature :

void stepInterpretation(LPY::Lsystem {lvalue},LPY::AxialTree {lvalue})

turtle_interpretation((Lsystem)arg1, (AxialTree)arg2) → None :

Apply interpretation with execContext().turtle.

C++ signature :

void turtle_interpretation(LPY::Lsystem {lvalue},LPY::AxialTree {lvalue})

turtle_interpretation( (Lsystem)arg1, (AxialTree)arg2, (object)arg3) -> None :

Apply interpretation with given turtle.

C++ signature :

void turtle_interpretation(LPY::Lsystem {lvalue},LPY::AxialTree {lvalue},PGL::Turtle {lvalue})

class openalea.lpy.__lpy_kernel__.Module

Bases: instance

isBracket((Module)arg1) → bool :

C++ signature :

bool isBracket(LPY::Module {lvalue})

isConsidered((Module)arg1, (ConsiderFilter)arg2) → bool :

C++ signature :

bool isConsidered(LPY::Module {lvalue},PGL::RefCountPtr<LPY::ConsiderFilter>)

isCut((Module)arg1) → bool :

C++ signature :

bool isCut(LPY::Module {lvalue})

isIgnored((Module)arg1, (ConsiderFilter)arg2) → bool :

C++ signature :

bool isIgnored(LPY::Module {lvalue},PGL::RefCountPtr<LPY::ConsiderFilter>)

isLeftBracket((Module)arg1) → bool :

C++ signature :

bool isLeftBracket(LPY::Module {lvalue})

isNull((Module)arg1) → bool :

C++ signature :

bool isNull(LPY::Module {lvalue})

isRequest((Module)arg1) → bool :

C++ signature :

bool isRequest(LPY::Module {lvalue})

isRightBracket((Module)arg1) → bool :

C++ signature :

bool isRightBracket(LPY::Module {lvalue})

isinstance((Module)arg1, (ModuleClass)arg2) → bool :

C++ signature :

bool isinstance(LPY::Module {lvalue},PGL::RefCountPtr<LPY::ModuleClass>)

property mclass

property name

scale((Module)arg1) → int :

C++ signature :

int scale(LPY::Module {lvalue})

class openalea.lpy.__lpy_kernel__.ModuleCategory

Bases: enum

Color = openalea.lpy.__lpy_kernel__.ModuleCategory.Color

None = openalea.lpy.__lpy_kernel__.ModuleCategory.None

PatternMatching = openalea.lpy.__lpy_kernel__.ModuleCategory.PatternMatching

Position = openalea.lpy.__lpy_kernel__.ModuleCategory.Position

Primitive = openalea.lpy.__lpy_kernel__.ModuleCategory.Primitive

Request = openalea.lpy.__lpy_kernel__.ModuleCategory.Request

Rotation = openalea.lpy.__lpy_kernel__.ModuleCategory.Rotation

Scale = openalea.lpy.__lpy_kernel__.ModuleCategory.Scale

StringManipulation = openalea.lpy.__lpy_kernel__.ModuleCategory.StringManipulation

Structure = openalea.lpy.__lpy_kernel__.ModuleCategory.Structure

Tropism = openalea.lpy.__lpy_kernel__.ModuleCategory.Tropism

UserDefined = openalea.lpy.__lpy_kernel__.ModuleCategory.UserDefined

Width = openalea.lpy.__lpy_kernel__.ModuleCategory.Width

as_integer_ratio()

Return a pair of integers, whose ratio is equal to the original int.

The ratio is in lowest terms and has a positive denominator.

>>> (10).as_integer_ratio()
(10, 1)
>>> (-10).as_integer_ratio()
(-10, 1)
>>> (0).as_integer_ratio()
(0, 1)

bit_count()

Number of ones in the binary representation of the absolute value of self.

Also known as the population count.

>>> bin(13)
'0b1101'
>>> (13).bit_count()
3

bit_length()

Number of bits necessary to represent self in binary.

>>> bin(37)
'0b100101'
>>> (37).bit_length()
6

conjugate()

Returns self, the complex conjugate of any int.

denominator

the denominator of a rational number in lowest terms

classmethod from_bytes(bytes, byteorder='big', *, signed=False)

Return the integer represented by the given array of bytes.

bytes

Holds the array of bytes to convert. The argument must either support the buffer protocol or be an iterable object producing bytes. Bytes and bytearray are examples of built-in objects that support the buffer protocol.

byteorder

The byte order used to represent the integer. If byteorder is ‘big’, the most significant byte is at the beginning of the byte array. If byteorder is ‘little’, the most significant byte is at the end of the byte array. To request the native byte order of the host system, use sys.byteorder as the byte order value. Default is to use ‘big’.

signed

Indicates whether two’s complement is used to represent the integer.

imag

the imaginary part of a complex number

is_integer()

Returns True. Exists for duck type compatibility with float.is_integer.

name

names = {'Color': openalea.lpy.__lpy_kernel__.ModuleCategory.Color, 'None': openalea.lpy.__lpy_kernel__.ModuleCategory.None, 'PatternMatching': openalea.lpy.__lpy_kernel__.ModuleCategory.PatternMatching, 'Position': openalea.lpy.__lpy_kernel__.ModuleCategory.Position, 'Primitive': openalea.lpy.__lpy_kernel__.ModuleCategory.Primitive, 'Request': openalea.lpy.__lpy_kernel__.ModuleCategory.Request, 'Rotation': openalea.lpy.__lpy_kernel__.ModuleCategory.Rotation, 'Scale': openalea.lpy.__lpy_kernel__.ModuleCategory.Scale, 'StringManipulation': openalea.lpy.__lpy_kernel__.ModuleCategory.StringManipulation, 'Structure': openalea.lpy.__lpy_kernel__.ModuleCategory.Structure, 'Tropism': openalea.lpy.__lpy_kernel__.ModuleCategory.Tropism, 'UserDefined': openalea.lpy.__lpy_kernel__.ModuleCategory.UserDefined, 'Width': openalea.lpy.__lpy_kernel__.ModuleCategory.Width}

numerator

the numerator of a rational number in lowest terms

real

the real part of a complex number

to_bytes(length=1, byteorder='big', *, signed=False)

Return an array of bytes representing an integer.

length

Length of bytes object to use. An OverflowError is raised if the integer is not representable with the given number of bytes. Default is length 1.

byteorder

The byte order used to represent the integer. If byteorder is ‘big’, the most significant byte is at the beginning of the byte array. If byteorder is ‘little’, the most significant byte is at the end of the byte array. To request the native byte order of the host system, use sys.byteorder as the byte order value. Default is to use ‘big’.

signed

Determines whether two’s complement is used to represent the integer. If signed is False and a negative integer is given, an OverflowError is raised.

values = {0: openalea.lpy.__lpy_kernel__.ModuleCategory.None, 1: openalea.lpy.__lpy_kernel__.ModuleCategory.Structure, 2: openalea.lpy.__lpy_kernel__.ModuleCategory.Rotation, 3: openalea.lpy.__lpy_kernel__.ModuleCategory.Position, 4: openalea.lpy.__lpy_kernel__.ModuleCategory.Scale, 5: openalea.lpy.__lpy_kernel__.ModuleCategory.Primitive, 6: openalea.lpy.__lpy_kernel__.ModuleCategory.Width, 7: openalea.lpy.__lpy_kernel__.ModuleCategory.Color, 8: openalea.lpy.__lpy_kernel__.ModuleCategory.Tropism, 9: openalea.lpy.__lpy_kernel__.ModuleCategory.Request, 11: openalea.lpy.__lpy_kernel__.ModuleCategory.StringManipulation, 12: openalea.lpy.__lpy_kernel__.ModuleCategory.PatternMatching, 13: openalea.lpy.__lpy_kernel__.ModuleCategory.UserDefined}

class openalea.lpy.__lpy_kernel__.ModuleClass

Bases: instance

DEFAULT_SCALE = 2147483647

property aliases

property bases

property category

property documentation

static get((str)name) → ModuleClass :

Get a module class from the name of the module

C++ signature :

PGL::RefCountPtr<LPY::ModuleClass> get(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

getNamedParameterNb((ModuleClass)arg1) → int :

C++ signature :

unsigned long getNamedParameterNb(LPY::ModuleClass {lvalue})

getParameterPosition((ModuleClass)arg1, (str)arg2) → int :

C++ signature :

unsigned long getParameterPosition(LPY::ModuleClass {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

getReferenceCount((ModuleClass)arg1) → int :

C++ signature :

unsigned long getReferenceCount(LPY::ModuleClass {lvalue})

hasParameter((ModuleClass)arg1, (str)arg2) → bool :

C++ signature :

bool hasParameter(LPY::ModuleClass {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

property id

isPredefined((ModuleClass)arg1) → bool :

C++ signature :

bool isPredefined(LPY::ModuleClass {lvalue})

issubclass((ModuleClass)arg1, (ModuleClass)arg2) → bool :

C++ signature :

bool issubclass(LPY::ModuleClass {lvalue},PGL::RefCountPtr<LPY::ModuleClass>)

property name

property parameterNames

predefinedClasses = [ModuleClass('',0,['None']), ModuleClass('[',1,['SB']), ModuleClass(']',2,['EB']), ModuleClass('=]',3), ModuleClass('F',4), ModuleClass('f',5), ModuleClass('nF',6), ModuleClass('X',7,['MouseIns']), ModuleClass('%',8,['Cut']), ModuleClass('*',9,['any']), ModuleClass('x',10,['repexp','all']), ModuleClass('or',11,['||']), ModuleClass('?P',12,['GetPos']), ModuleClass('?H',13,['GetHead']), ModuleClass('?U',14,['GetUp']), ModuleClass('?L',15,['GetLeft']), ModuleClass('?R',16,['GetRight']), ModuleClass('?F',17,['GetFrame']), ModuleClass('@Gc',18,['StartGC']), ModuleClass('@Ge',19,['EndGC']), ModuleClass('{',20,['BP']), ModuleClass('}',21,['EP']), ModuleClass('.',22,['PP']), ModuleClass('@M',23,['MoveTo']), ModuleClass('MoveRel',24), ModuleClass('LineTo',25), ModuleClass('OLineTo',26), ModuleClass('Pinpoint',27), ModuleClass('LineRel',28), ModuleClass('OLineRel',29), ModuleClass('PinpointRel',30), ModuleClass('@R',31,['SetHead']), ModuleClass('EulerAngles',32), ModuleClass('+',33,['Left']), ModuleClass('-',34,['Right']), ModuleClass('^',35,['Up']), ModuleClass('&',36,['Down']), ModuleClass('/',37,['RollL']), ModuleClass('\',38,['RollR']), ModuleClass('iRollL',39), ModuleClass('iRollR',40), ModuleClass('|',41,['TurnAround']), ModuleClass('@v',42,['RollToVert']), ModuleClass('@h',43,['RollToHorizontal']), ModuleClass('@O',44,['Sphere']), ModuleClass('@B',45,['Box']), ModuleClass('@b',46,['Quad']), ModuleClass('@o',47,['Circle']), ModuleClass('@L',48,['Label']), ModuleClass('_',49,['IncWidth']), ModuleClass('!',50,['DecWidth']), ModuleClass('SetWidth',51), ModuleClass(';',52,['IncColor']), ModuleClass(',',53,['DecColor']), ModuleClass('SetColor',54), ModuleClass('InterpolateColors',55), ModuleClass('TextureBaseColor',56), ModuleClass('InterpolateTextureBaseColors',57), ModuleClass('@Dd',58,['DivScale']), ModuleClass('@Di',59,['MultScale']), ModuleClass('@D',60,['SetScale']), ModuleClass('surface',61), ModuleClass('~',62), ModuleClass('@g',63,['PglShape']), ModuleClass('Frame',64), ModuleClass('Arrow',65), ModuleClass('@Ts',66,['Elasticity']), ModuleClass('@Tp',67,['Tropism']), ModuleClass('SetContour',68), ModuleClass('SectionResolution',69), ModuleClass('SetGuide',70), ModuleClass('EndGuide',71), ModuleClass('Sweep',72), ModuleClass('PositionOnGuide',73), ModuleClass('TextureScale',74), ModuleClass('TextureUScale',75), ModuleClass('TextureVScale',76,['TextureVCoeff']), ModuleClass('TextureTranslation',77), ModuleClass('TextureRotation',78), ModuleClass('TextureTransformation',79), ModuleClass('LeftReflection',80), ModuleClass('UpReflection',81), ModuleClass('HeadingReflection',82), ModuleClass('@2D',83,['StartScreenProjection']), ModuleClass('@3D',84,['EndScreenProjection']), ModuleClass('?I',85,['GetIterator']), ModuleClass('$',86,['GetModule']), ModuleClass('new',87,['newmodule'])]

property scale

class openalea.lpy.__lpy_kernel__.ModuleClassTable

Bases: instance

declare((ModuleClassTable)arg1, (str)arg2) → ModuleClass :

C++ signature :

PGL::RefCountPtr<LPY::ModuleClass> declare(LPY::ModuleClassTable {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

declare( (ModuleClassTable)arg1, (ModuleClass)arg2) -> bool :

C++ signature :

bool declare(LPY::ModuleClassTable {lvalue},LPY::ModuleClass*)

empty((ModuleClassTable)arg1) → bool :

C++ signature :

bool empty(LPY::ModuleClassTable {lvalue})

find((ModuleClassTable)arg1, (str)arg2) → ModuleClass :

C++ signature :

PGL::RefCountPtr<LPY::ModuleClass> find(LPY::ModuleClassTable {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

find( (ModuleClassTable)arg1, (object)arg2) -> ModuleClass :

C++ signature :

PGL::RefCountPtr<LPY::ModuleClass> find(LPY::ModuleClassTable {lvalue},unsigned long)

static get() → ModuleClassTable :

C++ signature :

LPY::ModuleClassTable {lvalue} get()

getClasses((ModuleClassTable)arg1) → object :

C++ signature :

boost::python::api::object getClasses(LPY::ModuleClassTable*)

getNames((ModuleClassTable)arg1) → object :

C++ signature :

boost::python::api::object getNames(LPY::ModuleClassTable*)

property mandatory_declaration

remove((ModuleClassTable)arg1, (ModuleClass)arg2) → bool :

C++ signature :

bool remove(LPY::ModuleClassTable {lvalue},LPY::ModuleClass const*)

remove( (ModuleClassTable)arg1, (str)arg2) -> bool :

C++ signature :

bool remove(LPY::ModuleClassTable {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

size((ModuleClassTable)arg1) → int :

C++ signature :

unsigned long size(LPY::ModuleClassTable {lvalue})

class openalea.lpy.__lpy_kernel__.NodeModule

Bases: ParamModule

append((ParamModule)arg1, (object)arg2) → None :

C++ signature :

void append(LPY::ParamModule {lvalue},boost::python::api::object)

argSize((ParamModule)arg1) → int :

C++ signature :

unsigned long argSize(LPY::ParamModule {lvalue})

property args

children((NodeModule)arg1) → object :

C++ signature :

boost::python::api::object children(LPY::NodeModule const*)

complex((NodeModule)arg1) → object :

C++ signature :

boost::python::api::object complex(LPY::NodeModule const*)

complex( (NodeModule)arg1, (object)arg2) -> object :

C++ signature :

boost::python::api::object complex(LPY::NodeModule const*,int)

components((NodeModule)arg1) → object :

C++ signature :

boost::python::api::object components(LPY::NodeModule const*)

components_at_scale((NodeModule)arg1, (object)arg2) → object :

C++ signature :

boost::python::api::object components_at_scale(LPY::NodeModule const*,int)

directSon(**kwargs)

deprecated function. See direct_child

direct_child((NodeModule)arg1) → object :

C++ signature :

boost::python::api::object direct_child(LPY::NodeModule const*)

empty((ParamModule)arg1) → bool :

C++ signature :

bool empty(LPY::ParamModule {lvalue})

father(**kwargs)

deprecated function. See parent

getNamedParameterNb((ParamModule)arg1) → int :

C++ signature :

unsigned long getNamedParameterNb(LPY::ParamModule {lvalue})

getNamedParameters((ParamModule)arg1, (dict)receiver[, (object)fromIndex=0]) → None :

C++ signature :

void getNamedParameters(LPY::ParamModule {lvalue},boost::python::dict {lvalue} [,unsigned long=0])

getParameter((ParamModule)arg1, (str)arg2) → object :

C++ signature :

boost::python::api::object getParameter(LPY::ParamModule {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

getParameterNames((ParamModule)arg1) → object :

C++ signature :

std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > getParameterNames(LPY::ParamModule {lvalue})

getParameterPosition((ParamModule)arg1, (str)arg2) → int :

C++ signature :

unsigned long getParameterPosition(LPY::ParamModule {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

hasArg((ParamModule)arg1) → bool :

C++ signature :

bool hasArg(LPY::ParamModule {lvalue})

hasParameter((ParamModule)arg1, (str)arg2) → bool :

C++ signature :

bool hasParameter(LPY::ParamModule {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

isBracket((Module)arg1) → bool :

C++ signature :

bool isBracket(LPY::Module {lvalue})

isConsidered((Module)arg1, (ConsiderFilter)arg2) → bool :

C++ signature :

bool isConsidered(LPY::Module {lvalue},PGL::RefCountPtr<LPY::ConsiderFilter>)

isCut((Module)arg1) → bool :

C++ signature :

bool isCut(LPY::Module {lvalue})

isIgnored((Module)arg1, (ConsiderFilter)arg2) → bool :

C++ signature :

bool isIgnored(LPY::Module {lvalue},PGL::RefCountPtr<LPY::ConsiderFilter>)

isLeftBracket((Module)arg1) → bool :

C++ signature :

bool isLeftBracket(LPY::Module {lvalue})

isNull((Module)arg1) → bool :

C++ signature :

bool isNull(LPY::Module {lvalue})

isRequest((Module)arg1) → bool :

C++ signature :

bool isRequest(LPY::Module {lvalue})

isRightBracket((Module)arg1) → bool :

C++ signature :

bool isRightBracket(LPY::Module {lvalue})

isRoot((NodeModule)arg1) → bool :

C++ signature :

bool isRoot(LPY::NodeModule {lvalue})

isValid((NodeModule)arg1) → bool :

C++ signature :

bool isValid(LPY::NodeModule {lvalue})

isinstance((Module)arg1, (ModuleClass)arg2) → bool :

C++ signature :

bool isinstance(LPY::Module {lvalue},PGL::RefCountPtr<LPY::ModuleClass>)

lateralSons(**kwargs)

deprecated function. See lateral_children

lateral_children((NodeModule)arg1) → object :

C++ signature :

boost::python::api::object lateral_children(LPY::NodeModule const*)

match((ParamModule)arg1, (str)arg2, (object)arg3) → bool :

C++ signature :

bool match(LPY::ParamModule {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >,unsigned long)

property mclass

property name

parent((NodeModule)arg1) → object :

C++ signature :

boost::python::api::object parent(LPY::NodeModule const*)

position((NodeModule)arg1) → int :

C++ signature :

unsigned long position(LPY::NodeModule {lvalue})

prepend((ParamModule)arg1, (object)arg2) → None :

C++ signature :

void prepend(LPY::ParamModule {lvalue},boost::python::api::object)

scale((Module)arg1) → int :

C++ signature :

int scale(LPY::Module {lvalue})

setParameter((ParamModule)arg1, (str)arg2, (object)arg3) → None :

C++ signature :

void setParameter(LPY::ParamModule {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >,boost::python::api::object)

sons(**kwargs)

deprecated function. See children

class openalea.lpy.__lpy_kernel__.PackedArgs

Bases: instance

class openalea.lpy.__lpy_kernel__.ParamModule

Bases: Module

append((ParamModule)arg1, (object)arg2) → None :

C++ signature :

void append(LPY::ParamModule {lvalue},boost::python::api::object)

argSize((ParamModule)arg1) → int :

C++ signature :

unsigned long argSize(LPY::ParamModule {lvalue})

property args

empty((ParamModule)arg1) → bool :

C++ signature :

bool empty(LPY::ParamModule {lvalue})

getNamedParameterNb((ParamModule)arg1) → int :

C++ signature :

unsigned long getNamedParameterNb(LPY::ParamModule {lvalue})

getNamedParameters((ParamModule)arg1, (dict)receiver[, (object)fromIndex=0]) → None :

C++ signature :

void getNamedParameters(LPY::ParamModule {lvalue},boost::python::dict {lvalue} [,unsigned long=0])

getParameter((ParamModule)arg1, (str)arg2) → object :

C++ signature :

boost::python::api::object getParameter(LPY::ParamModule {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

getParameterNames((ParamModule)arg1) → object :

C++ signature :

std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > getParameterNames(LPY::ParamModule {lvalue})

getParameterPosition((ParamModule)arg1, (str)arg2) → int :

C++ signature :

unsigned long getParameterPosition(LPY::ParamModule {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

hasArg((ParamModule)arg1) → bool :

C++ signature :

bool hasArg(LPY::ParamModule {lvalue})

hasParameter((ParamModule)arg1, (str)arg2) → bool :

C++ signature :

bool hasParameter(LPY::ParamModule {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

isBracket((Module)arg1) → bool :

C++ signature :

bool isBracket(LPY::Module {lvalue})

isConsidered((Module)arg1, (ConsiderFilter)arg2) → bool :

C++ signature :

bool isConsidered(LPY::Module {lvalue},PGL::RefCountPtr<LPY::ConsiderFilter>)

isCut((Module)arg1) → bool :

C++ signature :

bool isCut(LPY::Module {lvalue})

isIgnored((Module)arg1, (ConsiderFilter)arg2) → bool :

C++ signature :

bool isIgnored(LPY::Module {lvalue},PGL::RefCountPtr<LPY::ConsiderFilter>)

isLeftBracket((Module)arg1) → bool :

C++ signature :

bool isLeftBracket(LPY::Module {lvalue})

isNull((Module)arg1) → bool :

C++ signature :

bool isNull(LPY::Module {lvalue})

isRequest((Module)arg1) → bool :

C++ signature :

bool isRequest(LPY::Module {lvalue})

isRightBracket((Module)arg1) → bool :

C++ signature :

bool isRightBracket(LPY::Module {lvalue})

isinstance((Module)arg1, (ModuleClass)arg2) → bool :

C++ signature :

bool isinstance(LPY::Module {lvalue},PGL::RefCountPtr<LPY::ModuleClass>)

match((ParamModule)arg1, (str)arg2, (object)arg3) → bool :

C++ signature :

bool match(LPY::ParamModule {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >,unsigned long)

property mclass

property name

prepend((ParamModule)arg1, (object)arg2) → None :

C++ signature :

void prepend(LPY::ParamModule {lvalue},boost::python::api::object)

scale((Module)arg1) → int :

C++ signature :

int scale(LPY::Module {lvalue})

setParameter((ParamModule)arg1, (str)arg2, (object)arg3) → None :

C++ signature :

void setParameter(LPY::ParamModule {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >,boost::python::api::object)

class openalea.lpy.__lpy_kernel__.PatternModule

Bases: Module

append((PatternModule)arg1, (LsysVar)arg2) → None :

C++ signature :

void append(LPY::PatternModule {lvalue},LPY::LsysVar)

argSize((PatternModule)arg1) → int :

C++ signature :

unsigned long argSize(LPY::PatternModule {lvalue})

property args

class eMatchingMethod

Bases: enum

as_integer_ratio()

Return a pair of integers, whose ratio is equal to the original int.

The ratio is in lowest terms and has a positive denominator.

>>> (10).as_integer_ratio()
(10, 1)
>>> (-10).as_integer_ratio()
(-10, 1)
>>> (0).as_integer_ratio()
(0, 1)

bit_count()

Number of ones in the binary representation of the absolute value of self.

Also known as the population count.

>>> bin(13)
'0b1101'
>>> (13).bit_count()
3

bit_length()

Number of bits necessary to represent self in binary.

>>> bin(37)
'0b100101'
>>> (37).bit_length()
6

conjugate()

Returns self, the complex conjugate of any int.

denominator

the denominator of a rational number in lowest terms

eSimple = openalea.lpy.__lpy_kernel__.eMatchingMethod.eSimple

eWithStar = openalea.lpy.__lpy_kernel__.eMatchingMethod.eWithStar

eWithStarNValueConstraint = openalea.lpy.__lpy_kernel__.eMatchingMethod.eWithStarNValueConstraint

classmethod from_bytes(bytes, byteorder='big', *, signed=False)

Return the integer represented by the given array of bytes.

bytes

Holds the array of bytes to convert. The argument must either support the buffer protocol or be an iterable object producing bytes. Bytes and bytearray are examples of built-in objects that support the buffer protocol.

byteorder

The byte order used to represent the integer. If byteorder is ‘big’, the most significant byte is at the beginning of the byte array. If byteorder is ‘little’, the most significant byte is at the end of the byte array. To request the native byte order of the host system, use sys.byteorder as the byte order value. Default is to use ‘big’.

signed

Indicates whether two’s complement is used to represent the integer.

imag

the imaginary part of a complex number

is_integer()

Returns True. Exists for duck type compatibility with float.is_integer.

name

names = {'eSimple': openalea.lpy.__lpy_kernel__.eMatchingMethod.eSimple, 'eWithStar': openalea.lpy.__lpy_kernel__.eMatchingMethod.eWithStar, 'eWithStarNValueConstraint': openalea.lpy.__lpy_kernel__.eMatchingMethod.eWithStarNValueConstraint}

numerator

the numerator of a rational number in lowest terms

real

the real part of a complex number

to_bytes(length=1, byteorder='big', *, signed=False)

Return an array of bytes representing an integer.

length

Length of bytes object to use. An OverflowError is raised if the integer is not representable with the given number of bytes. Default is length 1.

byteorder

The byte order used to represent the integer. If byteorder is ‘big’, the most significant byte is at the beginning of the byte array. If byteorder is ‘little’, the most significant byte is at the end of the byte array. To request the native byte order of the host system, use sys.byteorder as the byte order value. Default is to use ‘big’.

signed

Determines whether two’s complement is used to represent the integer. If signed is False and a negative integer is given, an OverflowError is raised.

values = {0: openalea.lpy.__lpy_kernel__.eMatchingMethod.eSimple, 1: openalea.lpy.__lpy_kernel__.eMatchingMethod.eWithStar, 2: openalea.lpy.__lpy_kernel__.eMatchingMethod.eWithStarNValueConstraint}

eSimple = openalea.lpy.__lpy_kernel__.eMatchingMethod.eSimple

eWithStar = openalea.lpy.__lpy_kernel__.eMatchingMethod.eWithStar

eWithStarNValueConstraint = openalea.lpy.__lpy_kernel__.eMatchingMethod.eWithStarNValueConstraint

empty((PatternModule)arg1) → bool :

C++ signature :

bool empty(LPY::PatternModule {lvalue})

getNamedParameterNb((PatternModule)arg1) → int :

C++ signature :

unsigned long getNamedParameterNb(LPY::PatternModule {lvalue})

getNamedParameters((PatternModule)arg1, (dict)receiver[, (object)fromIndex=0]) → None :

C++ signature :

void getNamedParameters(LPY::PatternModule {lvalue},boost::python::dict {lvalue} [,unsigned long=0])

getParameter((PatternModule)arg1, (str)arg2) → LsysVar :

C++ signature :

LPY::LsysVar getParameter(LPY::PatternModule {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

getParameterNames((PatternModule)arg1) → object :

C++ signature :

std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > getParameterNames(LPY::PatternModule {lvalue})

getParameterPosition((PatternModule)arg1, (str)arg2) → int :

C++ signature :

unsigned long getParameterPosition(LPY::PatternModule {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

getVarNb((PatternModule)arg1) → int :

C++ signature :

unsigned long getVarNb(LPY::PatternModule {lvalue})

hasArg((PatternModule)arg1) → bool :

C++ signature :

bool hasArg(LPY::PatternModule {lvalue})

hasParameter((PatternModule)arg1, (str)arg2) → bool :

C++ signature :

bool hasParameter(LPY::PatternModule {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

isBracket((Module)arg1) → bool :

C++ signature :

bool isBracket(LPY::Module {lvalue})

isConsidered((Module)arg1, (ConsiderFilter)arg2) → bool :

C++ signature :

bool isConsidered(LPY::Module {lvalue},PGL::RefCountPtr<LPY::ConsiderFilter>)

isCut((Module)arg1) → bool :

C++ signature :

bool isCut(LPY::Module {lvalue})

isIgnored((Module)arg1, (ConsiderFilter)arg2) → bool :

C++ signature :

bool isIgnored(LPY::Module {lvalue},PGL::RefCountPtr<LPY::ConsiderFilter>)

isLeftBracket((Module)arg1) → bool :

C++ signature :

bool isLeftBracket(LPY::Module {lvalue})

isNull((Module)arg1) → bool :

C++ signature :

bool isNull(LPY::Module {lvalue})

isRequest((Module)arg1) → bool :

C++ signature :

bool isRequest(LPY::Module {lvalue})

isRightBracket((Module)arg1) → bool :

C++ signature :

bool isRightBracket(LPY::Module {lvalue})

isinstance((Module)arg1, (ModuleClass)arg2) → bool :

C++ signature :

bool isinstance(LPY::Module {lvalue},PGL::RefCountPtr<LPY::ModuleClass>)

matchingMethod = openalea.lpy.__lpy_kernel__.eMatchingMethod.eWithStarNValueConstraint

property mclass

property name

prepend((PatternModule)arg1, (LsysVar)arg2) → None :

C++ signature :

void prepend(LPY::PatternModule {lvalue},LPY::LsysVar)

scale((Module)arg1) → int :

C++ signature :

int scale(LPY::Module {lvalue})

setParameter((PatternModule)arg1, (str)arg2, (LsysVar)arg3) → None :

C++ signature :

void setParameter(LPY::PatternModule {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >,LPY::LsysVar)

varnames((PatternModule)arg1) → object :

C++ signature :

boost::python::api::object varnames(LPY::PatternModule*)

class openalea.lpy.__lpy_kernel__.PatternString

Bases: instance

append((PatternString)arg1, (PatternModule)arg2) → None :

C++ signature :

void append(LPY::PatternString {lvalue},LPY::PatternModule)

append( (PatternString)arg1, (PatternString)arg2) -> None :

C++ signature :

void append(LPY::PatternString {lvalue},LPY::PatternString)

append( (PatternString)arg1, (str)arg2) -> None :

C++ signature :

void append(LPY::PatternString*,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

argSize((PatternString)arg1) → int :

C++ signature :

unsigned long argSize(LPY::PatternString {lvalue})

beginBracket((PatternString)arg1, (object)arg2[, (object)startingAfterPos=False]) → object :

C++ signature :

boost::python::api::object beginBracket(LPY::PatternString*,int [,bool=False])

children((PatternString)arg1, (object)pos[, (ConsiderFilter)filter=None]) → object :

C++ signature :

boost::python::api::object children(LPY::PatternString*,int [,LPY::ConsiderFilter*=None])

children( (PatternString)arg1, (object)pos, (str)edge_type [, (ConsiderFilter)filter=None]) -> object :

C++ signature :

boost::python::api::object children(LPY::PatternString*,int,char [,LPY::ConsiderFilter*=None])

clear((PatternString)arg1) → None :

C++ signature :

void clear(LPY::PatternString {lvalue})

complex((PatternString)arg1, (object)arg2, (object)pos[, (ConsiderFilter)filter=None]) → object :

C++ signature :

boost::python::api::object complex(LPY::PatternString*,int,int [,LPY::ConsiderFilter*=None])

complex( (PatternString)pos, (object)scale [, (ConsiderFilter)filter=None]) -> object :

C++ signature :

boost::python::api::object complex(LPY::PatternString*,int [,LPY::ConsiderFilter*=None])

components((PatternString)arg1, (object)pos[, (ConsiderFilter)filter=None]) → object :

C++ signature :

boost::python::api::object components(LPY::PatternString*,int [,LPY::ConsiderFilter*=None])

components_at_scale((PatternString)arg1, (object)pos, (object)scale[, (ConsiderFilter)filter=None]) → object :

C++ signature :

boost::python::api::object components_at_scale(LPY::PatternString*,int,int [,LPY::ConsiderFilter*=None])

directSon(**kwargs)

deprecated function. See direct_child

direct_child((PatternString)arg1, (object)pos[, (ConsiderFilter)filter=None]) → object :

C++ signature :

boost::python::api::object direct_child(LPY::PatternString*,int [,LPY::ConsiderFilter*=None])

empty((PatternString)arg1) → bool :

C++ signature :

bool empty(LPY::PatternString {lvalue})

endBracket((PatternString)arg1, (object)arg2[, (object)startingBeforePos=False]) → object :

C++ signature :

boost::python::api::object endBracket(LPY::PatternString*,int [,bool=False])

father(**kwargs)

deprecated function. See parent

getVarNb((PatternString)arg1) → int :

C++ signature :

unsigned long getVarNb(LPY::PatternString {lvalue})

hasRequestModule((PatternString)arg1) → bool :

C++ signature :

bool hasRequestModule(LPY::PatternString {lvalue})

insertAt((PatternString)arg1, (object)arg2, (PatternModule)arg3) → None :

C++ signature :

void insertAt(LPY::PatternString {lvalue},int,LPY::PatternModule)

insertAt( (PatternString)arg1, (object)arg2, (PatternString)arg3) -> None :

C++ signature :

void insertAt(LPY::PatternString {lvalue},int,LPY::PatternString)

insertAt( (PatternString)arg1, (object)arg2, (str)arg3) -> None :

C++ signature :

void insertAt(LPY::PatternString*,int,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

isAPath((PatternString)arg1) → bool :

C++ signature :

bool isAPath(LPY::PatternString {lvalue})

lateralSons(**kwargs)

deprecated function. See lateral_children

lateral_children((PatternString)arg1, (object)pos[, (ConsiderFilter)filter=None]) → object :

C++ signature :

boost::python::api::object lateral_children(LPY::PatternString*,int [,LPY::ConsiderFilter*=None])

parent((PatternString)arg1, (object)pos[, (ConsiderFilter)filter=None]) → object :

C++ signature :

boost::python::api::object parent(LPY::PatternString*,int [,LPY::ConsiderFilter*=None])

predecessor_at_level((PatternString)arg1, (object)pos, (object)level[, (ConsiderFilter)filter=None]) → object :

C++ signature :

boost::python::api::object predecessor_at_level(LPY::PatternString*,int,int [,LPY::ConsiderFilter*=None])

predecessor_at_scale((PatternString)arg1, (object)pos, (object)scale[, (ConsiderFilter)filter=None]) → object :

C++ signature :

boost::python::api::object predecessor_at_scale(LPY::PatternString*,int,int [,LPY::ConsiderFilter*=None])

prepend((PatternString)arg1, (PatternModule)arg2) → None :

C++ signature :

void prepend(LPY::PatternString {lvalue},LPY::PatternModule)

prepend( (PatternString)arg1, (PatternString)arg2) -> None :

C++ signature :

void prepend(LPY::PatternString {lvalue},LPY::PatternString)

prepend( (PatternString)arg1, (str)arg2) -> None :

C++ signature :

void prepend(LPY::PatternString*,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

roots((PatternString)arg1[, (ConsiderFilter)filter=None]) → object :

C++ signature :

boost::python::api::object roots(LPY::PatternString* [,LPY::ConsiderFilter*=None])

sons(**kwargs)

deprecated function. See children

successor_at_level((PatternString)arg1, (object)pos, (object)level[, (ConsiderFilter)filter=None]) → object :

C++ signature :

boost::python::api::object successor_at_level(LPY::PatternString*,int,int [,LPY::ConsiderFilter*=None])

successor_at_scale((PatternString)arg1, (object)pos, (object)scale[, (ConsiderFilter)filter=None]) → object :

C++ signature :

boost::python::api::object successor_at_scale(LPY::PatternString*,int,int [,LPY::ConsiderFilter*=None])

varnames((PatternString)arg1) → object :

C++ signature :

boost::python::api::object varnames(LPY::PatternString*)

wellBracketed((PatternString)arg1) → bool :

C++ signature :

bool wellBracketed(LPY::PatternString {lvalue})

openalea.lpy.__lpy_kernel__.Stop() → None :

C++ signature :

void Stop()

class openalea.lpy.__lpy_kernel__.StringMatching

Bases: instance

addIdentity((StringMatching)arg1, (object)arg2) → None :

C++ signature :

void addIdentity(LPY::StringMatching {lvalue},unsigned long)

append((StringMatching)arg1, (object)arg2, (object)arg3) → None :

C++ signature :

void append(LPY::StringMatching {lvalue},unsigned long,unsigned long)

begin((StringMatching)arg1) → const_iterator :

C++ signature :

LPY::StringMatching::const_iterator begin(LPY::StringMatching {lvalue})

class const_iterator

Bases: instance

increment((const_iterator)arg1) → None :

C++ signature :

void increment(LPY::StringMatching::const_iterator {lvalue})

next((const_iterator)arg1) → int :

C++ signature :

unsigned long next(LPY::StringMatching::const_iterator {lvalue})

nextValues((const_iterator)arg1) → object :

C++ signature :

boost::python::api::object nextValues(LPY::StringMatching::const_iterator {lvalue})

original((const_iterator)arg1) → int :

C++ signature :

unsigned long original(LPY::StringMatching::const_iterator {lvalue})

target((const_iterator)arg1) → int :

C++ signature :

unsigned long target(LPY::StringMatching::const_iterator {lvalue})

values((const_iterator)arg1) → object :

C++ signature :

boost::python::api::object values(LPY::StringMatching::const_iterator {lvalue})

end((StringMatching)arg1) → const_iterator :

C++ signature :

LPY::StringMatching::const_iterator end(LPY::StringMatching {lvalue})

openalea.lpy.__lpy_kernel__.backward() → None :

C++ signature :

void backward()

openalea.lpy.__lpy_kernel__.cleanPlotter() → None :

C++ signature :

void cleanPlotter()

openalea.lpy.__lpy_kernel__.context() → LsysContext :

Return the current L-system context of execution. Rather use execContext.

C++ signature :

LPY::LsysContext* context()

openalea.lpy.__lpy_kernel__.declare((str)arg1) → None :

C++ signature :

void declare(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

class openalea.lpy.__lpy_kernel__.eConsiderMethod

Bases: enum

as_integer_ratio()

Return a pair of integers, whose ratio is equal to the original int.

The ratio is in lowest terms and has a positive denominator.

>>> (10).as_integer_ratio()
(10, 1)
>>> (-10).as_integer_ratio()
(-10, 1)
>>> (0).as_integer_ratio()
(0, 1)

bit_count()

Number of ones in the binary representation of the absolute value of self.

Also known as the population count.

>>> bin(13)
'0b1101'
>>> (13).bit_count()
3

bit_length()

Number of bits necessary to represent self in binary.

>>> bin(37)
'0b100101'
>>> (37).bit_length()
6

conjugate()

Returns self, the complex conjugate of any int.

denominator

the denominator of a rational number in lowest terms

eConsider = openalea.lpy.__lpy_kernel__.eConsiderMethod.eConsider

eIgnore = openalea.lpy.__lpy_kernel__.eConsiderMethod.eIgnore

classmethod from_bytes(bytes, byteorder='big', *, signed=False)

Return the integer represented by the given array of bytes.

bytes

Holds the array of bytes to convert. The argument must either support the buffer protocol or be an iterable object producing bytes. Bytes and bytearray are examples of built-in objects that support the buffer protocol.

byteorder

The byte order used to represent the integer. If byteorder is ‘big’, the most significant byte is at the beginning of the byte array. If byteorder is ‘little’, the most significant byte is at the end of the byte array. To request the native byte order of the host system, use sys.byteorder as the byte order value. Default is to use ‘big’.

signed

Indicates whether two’s complement is used to represent the integer.

imag

the imaginary part of a complex number

is_integer()

Returns True. Exists for duck type compatibility with float.is_integer.

name

names = {'eConsider': openalea.lpy.__lpy_kernel__.eConsiderMethod.eConsider, 'eIgnore': openalea.lpy.__lpy_kernel__.eConsiderMethod.eIgnore}

numerator

the numerator of a rational number in lowest terms

real

the real part of a complex number

to_bytes(length=1, byteorder='big', *, signed=False)

Return an array of bytes representing an integer.

length

Length of bytes object to use. An OverflowError is raised if the integer is not representable with the given number of bytes. Default is length 1.

byteorder

The byte order used to represent the integer. If byteorder is ‘big’, the most significant byte is at the beginning of the byte array. If byteorder is ‘little’, the most significant byte is at the end of the byte array. To request the native byte order of the host system, use sys.byteorder as the byte order value. Default is to use ‘big’.

signed

Determines whether two’s complement is used to represent the integer. If signed is False and a negative integer is given, an OverflowError is raised.

values = {0: openalea.lpy.__lpy_kernel__.eConsiderMethod.eConsider, 1: openalea.lpy.__lpy_kernel__.eConsiderMethod.eIgnore}

class openalea.lpy.__lpy_kernel__.eDirection

Bases: enum

as_integer_ratio()

Return a pair of integers, whose ratio is equal to the original int.

The ratio is in lowest terms and has a positive denominator.

>>> (10).as_integer_ratio()
(10, 1)
>>> (-10).as_integer_ratio()
(-10, 1)
>>> (0).as_integer_ratio()
(0, 1)

bit_count()

Number of ones in the binary representation of the absolute value of self.

Also known as the population count.

>>> bin(13)
'0b1101'
>>> (13).bit_count()
3

bit_length()

Number of bits necessary to represent self in binary.

>>> bin(37)
'0b100101'
>>> (37).bit_length()
6

conjugate()

Returns self, the complex conjugate of any int.

denominator

the denominator of a rational number in lowest terms

eBackward = openalea.lpy.__lpy_kernel__.eDirection.eBackward

eForward = openalea.lpy.__lpy_kernel__.eDirection.eForward

classmethod from_bytes(bytes, byteorder='big', *, signed=False)

Return the integer represented by the given array of bytes.

bytes

Holds the array of bytes to convert. The argument must either support the buffer protocol or be an iterable object producing bytes. Bytes and bytearray are examples of built-in objects that support the buffer protocol.

byteorder

The byte order used to represent the integer. If byteorder is ‘big’, the most significant byte is at the beginning of the byte array. If byteorder is ‘little’, the most significant byte is at the end of the byte array. To request the native byte order of the host system, use sys.byteorder as the byte order value. Default is to use ‘big’.

signed

Indicates whether two’s complement is used to represent the integer.

imag

the imaginary part of a complex number

is_integer()

Returns True. Exists for duck type compatibility with float.is_integer.

name

names = {'eBackward': openalea.lpy.__lpy_kernel__.eDirection.eBackward, 'eForward': openalea.lpy.__lpy_kernel__.eDirection.eForward}

numerator

the numerator of a rational number in lowest terms

real

the real part of a complex number

to_bytes(length=1, byteorder='big', *, signed=False)

Return an array of bytes representing an integer.

length

Length of bytes object to use. An OverflowError is raised if the integer is not representable with the given number of bytes. Default is length 1.

byteorder

The byte order used to represent the integer. If byteorder is ‘big’, the most significant byte is at the beginning of the byte array. If byteorder is ‘little’, the most significant byte is at the end of the byte array. To request the native byte order of the host system, use sys.byteorder as the byte order value. Default is to use ‘big’.

signed

Determines whether two’s complement is used to represent the integer. If signed is False and a negative integer is given, an OverflowError is raised.

values = {0: openalea.lpy.__lpy_kernel__.eDirection.eForward, 1: openalea.lpy.__lpy_kernel__.eDirection.eBackward}

class openalea.lpy.__lpy_kernel__.eRuleType

Bases: enum

as_integer_ratio()

Return a pair of integers, whose ratio is equal to the original int.

The ratio is in lowest terms and has a positive denominator.

>>> (10).as_integer_ratio()
(10, 1)
>>> (-10).as_integer_ratio()
(-10, 1)
>>> (0).as_integer_ratio()
(0, 1)

bit_count()

Number of ones in the binary representation of the absolute value of self.

Also known as the population count.

>>> bin(13)
'0b1101'
>>> (13).bit_count()
3

bit_length()

Number of bits necessary to represent self in binary.

>>> bin(37)
'0b100101'
>>> (37).bit_length()
6

conjugate()

Returns self, the complex conjugate of any int.

denominator

the denominator of a rational number in lowest terms

eDecomposition = openalea.lpy.__lpy_kernel__.eRuleType.eDecomposition

eInterpretation = openalea.lpy.__lpy_kernel__.eRuleType.eInterpretation

eProduction = openalea.lpy.__lpy_kernel__.eRuleType.eProduction

classmethod from_bytes(bytes, byteorder='big', *, signed=False)

Return the integer represented by the given array of bytes.

bytes

Holds the array of bytes to convert. The argument must either support the buffer protocol or be an iterable object producing bytes. Bytes and bytearray are examples of built-in objects that support the buffer protocol.

byteorder

The byte order used to represent the integer. If byteorder is ‘big’, the most significant byte is at the beginning of the byte array. If byteorder is ‘little’, the most significant byte is at the end of the byte array. To request the native byte order of the host system, use sys.byteorder as the byte order value. Default is to use ‘big’.

signed

Indicates whether two’s complement is used to represent the integer.

imag

the imaginary part of a complex number

is_integer()

Returns True. Exists for duck type compatibility with float.is_integer.

name

names = {'eDecomposition': openalea.lpy.__lpy_kernel__.eRuleType.eDecomposition, 'eInterpretation': openalea.lpy.__lpy_kernel__.eRuleType.eInterpretation, 'eProduction': openalea.lpy.__lpy_kernel__.eRuleType.eProduction}

numerator

the numerator of a rational number in lowest terms

real

the real part of a complex number

to_bytes(length=1, byteorder='big', *, signed=False)

Return an array of bytes representing an integer.

length

Length of bytes object to use. An OverflowError is raised if the integer is not representable with the given number of bytes. Default is length 1.

byteorder

The byte order used to represent the integer. If byteorder is ‘big’, the most significant byte is at the beginning of the byte array. If byteorder is ‘little’, the most significant byte is at the end of the byte array. To request the native byte order of the host system, use sys.byteorder as the byte order value. Default is to use ‘big’.

signed

Determines whether two’s complement is used to represent the integer. If signed is False and a negative integer is given, an OverflowError is raised.

values = {0: openalea.lpy.__lpy_kernel__.eRuleType.eProduction, 1: openalea.lpy.__lpy_kernel__.eRuleType.eDecomposition, 2: openalea.lpy.__lpy_kernel__.eRuleType.eInterpretation}

openalea.lpy.__lpy_kernel__.execContext() → LsysContext :

Return the current L-system context of execution.

C++ signature :

LPY::LsysContext* execContext()

openalea.lpy.__lpy_kernel__.forward() → None :

C++ signature :

void forward()

openalea.lpy.__lpy_kernel__.frameDisplay([(object)enabled=True]) → None :

C++ signature :

void frameDisplay([ bool=True])

openalea.lpy.__lpy_kernel__.generateScene((AxialTree)arg1[, (object)arg2]) → object :

C++ signature :

boost::python::api::object generateScene(LPY::AxialTree {lvalue} [,PGL::PglTurtle {lvalue}])

openalea.lpy.__lpy_kernel__.getGroup() → int :

C++ signature :

unsigned long getGroup()

openalea.lpy.__lpy_kernel__.getIterationNb() → int :

C++ signature :

unsigned long getIterationNb()

openalea.lpy.__lpy_kernel__.helpTurtle() → str :

C++ signature :

std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > helpTurtle()

helpTurtle( (str)arg1) -> str :

C++ signature :

std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > helpTurtle(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

openalea.lpy.__lpy_kernel__.inLeftContext((PatternString)pattern[, (dict)parameters={}]) → bool :

C++ signature :

bool inLeftContext(LPY::PatternString [,boost::python::dict {lvalue}={}])

inLeftContext( (str)pattern [, (dict)parameters={}]) -> bool :

C++ signature :

bool inLeftContext(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > [,boost::python::dict {lvalue}={}])

openalea.lpy.__lpy_kernel__.inRightContext((PatternString)pattern[, (dict)parameters={}]) → bool :

C++ signature :

bool inRightContext(LPY::PatternString [,boost::python::dict {lvalue}={}])

inRightContext( (str)pattern [, (dict)parameters={}]) -> bool :

C++ signature :

bool inRightContext(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > [,boost::python::dict {lvalue}={}])

openalea.lpy.__lpy_kernel__.isAnimationEnabled() → bool :

C++ signature :

bool isAnimationEnabled()

openalea.lpy.__lpy_kernel__.isDeclared((str)arg1) → None :

C++ signature :

void isDeclared(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

openalea.lpy.__lpy_kernel__.isForward() → bool :

C++ signature :

bool isForward()

openalea.lpy.__lpy_kernel__.isFrameDisplayed() → bool :

C++ signature :

bool isFrameDisplayed()

openalea.lpy.__lpy_kernel__.isSelectionAlwaysRequired() → bool :

C++ signature :

bool isSelectionAlwaysRequired()

openalea.lpy.__lpy_kernel__.lstring2py((str)arg1) → str :

C++ signature :

std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > lstring2py(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

openalea.lpy.__lpy_kernel__.nsproduce((AxialTree)arg1) → None :

C++ signature :

void nsproduce(LPY::AxialTree)

nsproduce( (list)arg1) -> None :

C++ signature :

void nsproduce(boost::python::list)

nsproduce( (str)arg1) -> None :

C++ signature :

void nsproduce(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

openalea.lpy.__lpy_kernel__.pInLeftContext((object)patternid[, (dict)parameters={}]) → bool :

C++ signature :

bool pInLeftContext(unsigned long [,boost::python::dict {lvalue}={}])

openalea.lpy.__lpy_kernel__.pInRightContext((object)patternid[, (dict)parameters={}]) → bool :

C++ signature :

bool pInRightContext(unsigned long [,boost::python::dict {lvalue}={}])

openalea.lpy.__lpy_kernel__.plot((AxialTree)arg1[, (object)arg2]) → None :

C++ signature :

void plot(LPY::AxialTree {lvalue} [,PGL::PglTurtle {lvalue}])

openalea.lpy.__lpy_kernel__.pproduce()

object pproduce(tuple args, dict kwds) :

C++ signature :

object pproduce(tuple args, dict kwds)

openalea.lpy.__lpy_kernel__.registerPlotter((object)arg1) → None :

C++ signature :

void registerPlotter(boost::python::api::object)

openalea.lpy.__lpy_kernel__.requestSelection((str)message) → None :

C++ signature :

void requestSelection(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

openalea.lpy.__lpy_kernel__.setSelectionAlwaysRequired((object)arg1) → None :

C++ signature :

void setSelectionAlwaysRequired(bool)

openalea.lpy.__lpy_kernel__.turtle_interpretation((AxialTree)arg1, (object)arg2) → None :

C++ signature :

void turtle_interpretation(LPY::AxialTree {lvalue},PGL::Turtle {lvalue})

turtle_interpretation( (AxialTree)arg1, (object)arg2, (StringMatching)arg3) -> None :

C++ signature :

void turtle_interpretation(LPY::AxialTree {lvalue},PGL::Turtle {lvalue},LPY::StringMatching)

openalea.lpy.__lpy_kernel__.turtle_partial_interpretation((AxialTree)arg1, (object)arg2) → None :

C++ signature :

void turtle_partial_interpretation(LPY::AxialTree {lvalue},PGL::Turtle {lvalue})

openalea.lpy.__lpy_kernel__.undeclare((str)arg1) → None :

C++ signature :

void undeclare(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

openalea.lpy.__lpy_kernel__.useGroup((object)arg1) → None :

C++ signature :

void useGroup(unsigned long)