fix bug with **kwd; fix bug with lstring access of type l[i:]; add module class object in simulation; module can be created directly using moduleclass; set option early return default to false;fix bug with filename argument using lpy application

git-svn-id: svn+ssh://scm.gforge.inria.fr/svnroot/vplants/vplants/trunk/lpy@16886 ab253cce-29fb-0310-bb2f-979600cdbdeb

Author: fredboudon

share/extension/curve2Ddrawing.lpy

@@ -0,0 +1,104 @@
+from openalea.plantgl.all import *
+
+NbSteps = 20
+dt = 1./NbSteps
+print dt
+totlength = []
+
+def Start():
+  global totlength
+  totlength = [(0,length(0))]
+
+def plotCurve(data, xextend = None, yextend = None, pos = (0.1,-0.8), dim = (0.8,0.8), xtick = None, ytick = None ):
+  from math import ceil, floor
+  if len(data) > 1:
+    print data
+    if xextend:
+      minx, maxx = xextend
+    else :
+      minx = floor(min([x for x,y in data]))
+      maxx = ceil(max([x for x,y in data]))
+    if yextend:
+      miny, maxy = yextend
+    else :
+      miny = floor(min([y for x,y in data]))
+      maxy = ceil(max([y for x,y in data]))
+    xext = maxx - minx
+    yext = maxy - miny
+    x2Dlength, y2Dlength = dim
+    projx = lambda x: (x2Dlength*(x-minx)/xext)
+    projy = lambda y: (y2Dlength*(y-miny)/yext)
+    if xtick is None:
+      xtick = yext*0.1
+    if ytick is None:
+      ytick = xext*0.1
+    
+    data = [(projx(x),projy(y)) for x,y in data]
+    ticklength = 0.02
+    
+    nproduce [ @2D ,(3) @M(pos[0],pos[1]) @g(Polyline2D(data,width=2))
+    if miny <= 0 <= maxy:
+      nproduce ,(5) @g(Polyline2D([(projx(minx),projy(0)),(projx(maxx),projy(0))]))
+      cxtick = minx + xtick
+      while cxtick < maxx:
+        nproduce ,(5) @g(Polyline2D([(projx(cxtick),projy(-ticklength)),(projx(cxtick),projy(ticklength))]))
+        cxtick += xtick
+    if minx <= 0 <= maxx:
+      nproduce ,(2) @g(Polyline2D([(projx(0),projy(miny)),(projx(0),projy(maxy))]))
+      cytick = miny + ytick
+      while cytick < maxy:
+        nproduce ,(2) @g(Polyline2D([(projx(-ticklength),projy(cytick)),(projx(ticklength),projy(cytick))]))
+        cytick += ytick
+    nproduce ]
+
+#import matplotlib.pyplot as plt
+import pylab as plt
+
+def StartEach():
+  plt.close()
+
+def plotCurve2(data):
+  if len(data) > 1:
+    plt.plot([x for x in data], [y for y in data], '-', linewidth=2)
+    plt.show()
+    plt.draw()
+
+Axiom: I(0,length(0))
+
+derivation length: NbSteps
+production:
+
+I(t,l) :
+  nt = t+dt
+  if nt >= 1.0: nt = 1.0
+  l = length(nt)
+  totlength.append((nt,l))
+  produce I(nt,l)
+
+
+
+interpretation:
+
+I(t,l) :
+  plotCurve2(totlength)
+  plotCurve(totlength)
+  nproduce F(l) 
+
+
+endlsystem
+###### INITIALISATION ######
+
+__lpy_code_version__ = 1.1
+
+def __initialiseContext__(context):
+	import openalea.plantgl.all as pgl
+	length = pgl.NurbsCurve2D(	
+	    ctrlPointList = pgl.Point3Array([(0, 0, 1),(0.175114, 0.0522138, 1),(0.369245, 0.047519, 1),(0.369245, 0.619904, 1),(0.558015, 0.67878, 1),(1, 0.69864, 1)]) , 
+	    )
+	length.name = "length"
+	panel_0 = ({'active': True, 'visible': True, 'name': 'Panel 1'},[('Function',length)])
+	parameterset = [panel_0,]
+	context["__functions__"] = [('length',length),]
+	context["__curves__"] = []
+	context["__parameterset__"] = parameterset
+	context["length"] = pgl.QuantisedFunction(length)

src/cpp/abstractlstring.h

@@ -218,10 +218,13 @@ class AbstractLString {
   { return __conststring()[getValidIndex(i)]; }
 
   template<class StringType>
-  inline StringType getRange(int i, int j) const
+  inline StringType getRange(size_t ri, size_t rj) const
   {
-	size_t ri, rj; getValidIndices(i,j,ri,rj) ; 
-	return StringType(const_begin()+ri,const_begin()+rj);
+    const_iterator beg, end;
+    getValidIterators(ri, rj, beg, end);
+	//size_t ri, rj; getValidIndices(i,j,ri,rj) ; 
+    // printf("%i %i\n",ri,rj);
+	return StringType(beg,end);
   }
 
   inline void setAt(size_t i, const Module& m)
@@ -402,15 +405,20 @@ class AbstractLString {
 		return (size_t)i;
 	 }
 
-	 inline void getValidIndices(int i, int j, size_t& resi, size_t& resj) const {
-		size_t s = size();
-		if( i < 0 ) i += s;
-		if( j < 0 ) j += s;
-	    if( j > s ) j = s;
-		if (i < 0  || i >= s || j < i) throw PythonExc_IndexError("index out of range");
-		resi =(size_t)i;
-		resj =(size_t)j;
-	 }
+     inline void getValidIndices(int i, int j, size_t& resi, size_t& resj) const {
+        size_t s = size();
+        printf("%i, %i\n",i,j);
+        if( i < 0 ) i += s;
+        if( j < 0 ) j += s;
+        if( j > s ) j = s;
+        if (i < 0  || i >= s || j < i) throw PythonExc_IndexError("index out of range");
+        resi =(size_t)i;
+        resj =(size_t)j;
+     }
+
+     inline void getValidIndices(size_t& resi, size_t& resj) const {
+        if (resj == std::string::npos) resj = size();
+     }
 
 	 inline void getValidIterators(int i, int j, const_iterator& resi, const_iterator& resj) const {
 		size_t s = size();
@@ -421,6 +429,16 @@ class AbstractLString {
 		resi =const_begin()+i;
 		resj =const_begin()+j;
 	 }
+
+     inline void getValidIterators(size_t i, size_t j, const_iterator& resi, const_iterator& resj) const {
+        resi =const_begin()+i;
+        if (j == LONG_MAX) {
+            resj = const_end();
+        }
+        else {
+            resj =const_begin()+j;
+        }
+     }
 };
 
 /*---------------------------------------------------------------------------*/

src/cpp/lpy_parser.cpp

@@ -328,7 +328,7 @@ Lsystem::set( const std::string&   _rules , std::string * pycode,
   if (initpos != std::string::npos) endpycode = rules.begin()+initpos;
 
   while(_it!=endpycode){
-	printf("******'%c' %i\n",*_it,std::distance(begcode,_it));
+	// printf("******'%c' %i\n",*_it,std::distance(begcode,_it));
 	switch(mode){
 	case -1:
 	  {
@@ -398,7 +398,6 @@ Lsystem::set( const std::string&   _rules , std::string * pycode,
           if(has_keyword_pattern(_it,begcode,endpycode,"module")){
             code+=std::string(beg,_it2);
 			LpyParsing::ModLineDeclaration modules = LpyParsing::parse_moddeclaration_line(_it,endpycode);
-			code+="# "+std::string(_it2,_it);
 			int scale = ModuleClass::DEFAULT_SCALE;
 			ModuleClassList inheritance;
 			pgl_hash_map_string<boost::python::object> properties;
@@ -475,6 +474,12 @@ Lsystem::set( const std::string&   _rules , std::string * pycode,
 				if(scale != ModuleClass::DEFAULT_SCALE)mod->setScale(scale);
 				if(!inheritance.empty())mod->setBases(inheritance);
 			}
+            for(LpyParsing::ModDeclarationList::const_iterator itmod = modules.first.begin(); 
+                 itmod != modules.first.end(); ++itmod){
+                if (itmod != modules.first.begin()) code += " ; ";
+                code += itmod->name+" = ModuleClass.get('"+itmod->name+"')";
+            }
+            code+="# "+std::string(_it2,_it);
 			beg = _it;
 			toendlineA(_it,endpycode);
 		  }

src/cpp/lstringmatcher.cpp

@@ -94,7 +94,7 @@ bool LstringMatcher::inLeftContext(const PatternString& pattern, boost::python::
 bool LstringMatcher::pInRightContext(size_t patternid, boost::python::dict& args)
 {
    PatternString pattern = PatternStringManager::get().get_pattern(patternid);
-   return inLeftContext(pattern,args);
+   return inRightContext(pattern,args);
 }
 
 bool LstringMatcher::inRightContext(const PatternString& pattern, boost::python::dict& args)

src/cpp/lstringmatcher.h

@@ -73,6 +73,8 @@ class LstringMatcher : public TOOLS(RefCountObject) {
 
 typedef RCPtr<LstringMatcher> LstringMatcherPtr;
 
+class LsysContext;
+
 struct LstringMatcherMaintainer {
     LsysContext * context;
 

src/cpp/lsyscontext.cpp

@@ -367,7 +367,7 @@ void LsysContext::init_options()
 	option = options.add("Early return when no matching","Set whether the L-systems end prematurely if no matching has occured in the last iteration.","Processing");
 	option->addValue("Disabled",this,&LsysContext::setReturnIfNoMatching,false,"Disable early return.");
 	option->addValue("Enabled",this,&LsysContext::setReturnIfNoMatching,true,"Enable early return.");
-	option->setDefault(1);	
+	option->setDefault(0);	
 #if (PGL_VERSION >= 0x020B00)
 	/** warn if turtle has invalid value option */
 	option = options.add("Warning with Turtle inconsistency","Set whether a warning/error is raised when an invalid value is found during turtle processing.","Processing");

src/cpp/lsyscontext.h

@@ -157,7 +157,7 @@ class LPY_API LsysContext {
   /** static functions to access context */
   static inline LsysContext * currentContext() { return current(); }
   static LsysContext * current();
-  static inline LsysContext * globalContext(); 
+  static LsysContext * globalContext(); 
 
   // { return global(); }
   // static LsysContext * global();

src/cpp/lsysrule.cpp

@@ -535,18 +535,17 @@ LsysRule::match(const AxialTree& src,
 	ArgList args_ncd;
     if(!MatchingEngine::right_match(dest.const_begin(),dest.const_begin(),dest.const_end(),
 		                          __newrightcontext.const_begin(),__newrightcontext.const_end(),
-<<<<<<< .mine								  endposNewRightLastMatch,endposNewRight,args_ncd))return false;
-=======								  last_match,endpos2,args_ncd))
-        return false;
->>>>>>> .theirs	ArgsCollector::append_args(args,args_ncd);
+								  endposNewRightLastMatch,endposNewRight,args_ncd)) return false;
+    							  // last_match,endpos2,args_ncd)) return false;
+	ArgsCollector::append_args(args,args_ncd);
   }
 
   // right context
   AxialTree::const_iterator endposRight = endpos1;
   AxialTree::const_iterator endposRightLastMatch = last_match;
   if(!__rightcontext.empty()){
 	ArgList args_cd;
-    if(!MatchingEngine::right_match(endpos1,src.const_begin(),src.const_end(),
+    if(!MatchingEngine::right_match(endposRight,src.const_begin(),src.const_end(),
 		                          __rightcontext.const_begin(),__rightcontext.const_end(),
 								  endposRightLastMatch,endposRight,args_cd))return false;
 	ArgsCollector::append_args(args,args_cd);