fixing concurrency issue on incremental delaunay demo

jzy3d-api/src/api/org/jzy3d/plot3d/primitives/AbstractComposite.java

@@ -17,11 +17,9 @@ import org.jzy3d.plot3d.transform.Transform;
 import com.jogamp.opengl.GL;
 import com.jogamp.opengl.glu.GLU;
 
-
 /**
- * A Composite gathers several Drawable and provides default methods
+ * A Composite gathers several Drawable and provides default methods for
- * for rendering them all in one call.
+ * rendering them all in one call. <br>
- * <br>
  *
  * @author Martin Pernollet
  *
@@ -36,13 +34,17 @@ public abstract class AbstractComposite extends AbstractWireframeable implements
 
     /** Append a list of Drawables to this composite. */
     public void add(List<? extends AbstractDrawable> drawables) {
+        synchronized (components) {
             components.addAll(drawables);
         }
+    }
 
     /** Clear the list of Drawables from this composite. */
     public void clear() {
+        synchronized (components) {
             components.clear();
         }
+    }
 
     /** Add a Drawable to this composite. */
     public void add(AbstractDrawable drawable) {
@@ -89,8 +91,10 @@ public abstract class AbstractComposite extends AbstractWireframeable implements
         doDrawBounds(gl, glu, camera);
     }
 
-	/** Delegate transforming iteratively to all Drawable of this composite 
+    /**
-	 * and stores the given transform for keeping the ability of retrieving it.*/
+     * Delegate transforming iteratively to all Drawable of this composite and
+     * stores the given transform for keeping the ability of retrieving it.
+     */
     @Override
     public void setTransform(Transform transform) {
         this.transform = transform;
@@ -121,7 +125,10 @@ public abstract class AbstractComposite extends AbstractWireframeable implements
         return transform;
     }
 
-	/** Creates and return a BoundingBox3d that embed all available Drawable bounds.*/
+    /**
+     * Creates and return a BoundingBox3d that embed all available Drawable
+     * bounds.
+     */
     @Override
     public BoundingBox3d getBounds() {
         updateBounds();
@@ -143,69 +150,85 @@ public abstract class AbstractComposite extends AbstractWireframeable implements
 
     @Override
     public void applyGeometryTransform(Transform transform) {
+        synchronized (components) {
             for (AbstractDrawable c : components) {
                 c.applyGeometryTransform(transform);
             }
+        }
         // updateBounds(); no need, as computed by getBounds()
     }
 
-	
     /****************************************************************/
 
     @Override
     public void setWireframeColor(Color color) {
         super.setWireframeColor(color);
 
-		if(components != null)
+        if (components != null) {
+            synchronized (components) {
                 for (AbstractDrawable c : components) {
                     if (c != null && c instanceof AbstractWireframeable)
                         ((AbstractWireframeable) c).setWireframeColor(color);
                 }
             }
+        }
+    }
 
     @Override
     public void setWireframeDisplayed(boolean status) {
         super.setWireframeDisplayed(status);
 
-		if(components != null)
+        if (components != null) {
+            synchronized (components) {
                 for (AbstractDrawable c : components) {
                     if (c != null && c instanceof AbstractWireframeable)
                         ((AbstractWireframeable) c).setWireframeDisplayed(status);
                 }
             }
+        }
+    }
 
     @Override
     public void setWireframeWidth(float width) {
         super.setWireframeWidth(width);
 
-		if(components != null)
+        if (components != null) {
+            synchronized (components) {
                 for (AbstractDrawable c : components) {
                     if (c != null && c instanceof AbstractWireframeable)
                         ((AbstractWireframeable) c).setWireframeWidth(width);
                 }
             }
+        }
+    }
 
     @Override
     public void setFaceDisplayed(boolean status) {
         super.setFaceDisplayed(status);
 
-		if(components != null)
+        if (components != null) {
+            synchronized (components) {
                 for (AbstractDrawable c : components) {
                     if (c != null && c instanceof AbstractWireframeable)
                         ((AbstractWireframeable) c).setFaceDisplayed(status);
                 }
             }
+        }
+    }
 
     @Override
     public void setDisplayed(boolean status) {
         super.setDisplayed(status);
 
-		if(components != null)
+        if (components != null) {
+            synchronized (components) {
                 for (AbstractDrawable c : components) {
                     if (c != null && c instanceof AbstractWireframeable)
                         ((AbstractWireframeable) c).setDisplayed(status);
                 }
             }
+        }
+    }
 
     /****************************************************************/
 
@@ -214,12 +237,15 @@ public abstract class AbstractComposite extends AbstractWireframeable implements
         this.mapper = mapper;
 
         if (components != null) {
+
+            synchronized (components) {
                 for (AbstractDrawable d : components) {
                     if (d instanceof IMultiColorable)
                         ((IMultiColorable) d).setColorMapper(mapper);
                     else if (d instanceof ISingleColorable)
                         ((ISingleColorable) d).setColor(mapper.getColor(d.getBarycentre()));
                 }
+            }
 
             fireDrawableChanged(new DrawableChangedEvent(this, DrawableChangedEvent.FIELD_COLOR));
         }
@@ -236,10 +262,11 @@ public abstract class AbstractComposite extends AbstractWireframeable implements
         this.color = color;
 
         if (components != null) {
+            synchronized (components) {
                 for (AbstractDrawable d : components)
                     if (d instanceof ISingleColorable)
                         ((ISingleColorable) d).setColor(color);
-			
+            }
             fireDrawableChanged(new DrawableChangedEvent(this, DrawableChangedEvent.FIELD_COLOR));
         }
     }
@@ -269,8 +296,7 @@ public abstract class AbstractComposite extends AbstractWireframeable implements
                         output += "\n" + ((AbstractComposite) c).toString(depth + 1);
                     else
                         output += "\n" + Utils.blanks(depth + 1) + " Composite element[" + (k++) + "]:" + c.toString();
-				}
+                } else
-				else
                     output += Utils.blanks(depth + 1) + "(null)\n";
             }
         }
@@ -282,15 +308,14 @@ public abstract class AbstractComposite extends AbstractWireframeable implements
         return detailedToString;
     }
 
-	/** When to true, the {@link toString()} method will give the detail of each element 
+    /**
-	 * of this composite object in a tree like layout.
+     * When to true, the {@link toString()} method will give the detail of each
+     * element of this composite object in a tree like layout.
      */
     public void setDetailedToString(boolean detailedToString) {
         this.detailedToString = detailedToString;
     }
 
-
-
     /****************************************************************/
 
     protected List<AbstractDrawable> components = Collections.synchronizedList(new ArrayList<AbstractDrawable>());

jzy3d-api/src/api/org/jzy3d/plot3d/rendering/scene/Decomposition.java

@@ -6,7 +6,6 @@ import java.util.List;
 import org.jzy3d.plot3d.primitives.AbstractComposite;
 import org.jzy3d.plot3d.primitives.AbstractDrawable;
 
-
 public class Decomposition {
     public static ArrayList<AbstractDrawable> getDecomposition(List<AbstractDrawable> drawables) {
         ArrayList<AbstractDrawable> monotypes = new ArrayList<AbstractDrawable>();
@@ -26,6 +25,8 @@ public class Decomposition {
     public static ArrayList<AbstractDrawable> getDecomposition(AbstractComposite input) {
         ArrayList<AbstractDrawable> selection = new ArrayList<AbstractDrawable>();
 
+        // composite internally make use of synchronisation on its list of child, so we do so
+        synchronized (input.getDrawables()) {
             for (AbstractDrawable c : input.getDrawables()) {
                 if (c != null && c.isDisplayed()) {
                     if (c instanceof AbstractComposite)
@@ -34,6 +35,7 @@ public class Decomposition {
                         selection.add(c);
                 }
             }
+        }
         return selection;
     }
 }

jzy3d-api/src/api/org/jzy3d/plot3d/rendering/scene/Graph.java

@@ -255,12 +255,12 @@ public class Graph {
     public synchronized void setTransform(Transform transform) {
         this.transform = transform;
 
-        // synchronized(components){
+        synchronized (components) {
             for (AbstractDrawable c : components) {
                 if (c != null)
                     c.setTransform(transform);
             }
-        // }
+        }
     }
 
     /** Return the transform that was affected to this composite. */
@@ -344,8 +344,29 @@ public class Graph {
         return output;
     }
     
+    
+
     /* */
 
+    public boolean isSort() {
+        return sort;
+    }
+
+    /**
+     * Set sort to false to desactivate decomposition of drawable. 
+     * 
+     * This bypass ranking polygons w.r.t. camera. This will produce visual cue
+     * if the scene is dynamic (changing the list of polygons or viewpoints).
+     * @param sort
+     */
+    public void setSort(boolean sort) {
+        this.sort = sort;
+    }
+
+    public Scene getScene() {
+        return scene;
+    }
+
     protected List<AbstractDrawable> components;
     protected Scene scene;
     protected Transform transform;