diff --git a/plotly/plotlyfig.m b/plotly/plotlyfig.m
index 8a332d92..ee7057d0 100644
--- a/plotly/plotlyfig.m
+++ b/plotly/plotlyfig.m
@@ -573,10 +573,10 @@ function validate(obj)
                 
                 % get number of nbars for pie3
                 if strcmpi(obj.PlotOptions.TreatAs, 'pie3')
-                    obj.PlotOptions.nbars = 0;
+                    obj.PlotOptions.nbars{a} = 0;
                     for i = 1:length(plots)
                         if strcmpi(getGraphClass(plots(i)), 'surface')
-                            obj.PlotOptions.nbars = obj.PlotOptions.nbars + 1;
+                            obj.PlotOptions.nbars{a} = obj.PlotOptions.nbars{a} + 1;
                         end
                     end
                 end
diff --git a/plotly/plotlyfig_aux/core/updateAnnotation.m b/plotly/plotlyfig_aux/core/updateAnnotation.m
index 46e90139..4860eccd 100644
--- a/plotly/plotlyfig_aux/core/updateAnnotation.m
+++ b/plotly/plotlyfig_aux/core/updateAnnotation.m
@@ -91,15 +91,29 @@
 %-------------------------------------------------------------------------%
 
 %-text-%
-if ~strcmpi(obj.PlotOptions.TreatAs, 'pie3')
+if obj.State.Text(anIndex).Title
     obj.layout.annotations{anIndex}.text = parseString(text_data.String,text_data.Interpreter);
-    if obj.State.Text(anIndex).Title && isempty(text_data.String) 
+    if isempty(text_data.String) 
         obj.layout.annotations{anIndex}.text = '<b></b>'; %empty string annotation
     end
 else
-    obj.layout.annotations{anIndex}.text = '<b></b>'; 
+    if ~strcmpi(obj.PlotOptions.TreatAs, 'pie3')
+        obj.layout.annotations{anIndex}.text = parseString(text_data.String,text_data.Interpreter);
+    else
+        obj.layout.annotations{anIndex}.text = '<b></b>'; 
+    end
 end
 
+%-optional code flow-%
+% if ~strcmpi(obj.PlotOptions.TreatAs, 'pie3')
+%     obj.layout.annotations{anIndex}.text = parseString(text_data.String,text_data.Interpreter);
+%     if obj.State.Text(anIndex).Title && isempty(text_data.String) 
+%         obj.layout.annotations{anIndex}.text = '<b></b>'; %empty string annotation
+%     end
+% else
+%     obj.layout.annotations{anIndex}.text = '<b></b>'; 
+% end
+
 %-------------------------------------------------------------------------%
 
 if obj.State.Text(anIndex).Title
diff --git a/plotly/plotlyfig_aux/core/updateAxis.m b/plotly/plotlyfig_aux/core/updateAxis.m
index cd41f86f..1aec4ca6 100644
--- a/plotly/plotlyfig_aux/core/updateAxis.m
+++ b/plotly/plotlyfig_aux/core/updateAxis.m
@@ -96,11 +96,13 @@
 
 %-xaxis domain-%
 xaxis.domain = min([xo xo + w],1);
+scene.domain.x = min([xo xo + w],1);
 
 %-------------------------------------------------------------------------%
 
 %-yaxis domain-%
 yaxis.domain = min([yo yo + h],1);
+scene.domain.y = min([yo yo + h],1);
 
 %-------------------------------------------------------------------------%
 
@@ -135,6 +137,7 @@
 % update the layout field (do not overwrite source)
 if xsource == axIndex
     obj.layout = setfield(obj.layout,['xaxis' num2str(xsource)],xaxis);
+    obj.layout = setfield(obj.layout,['scene' num2str(xsource)],scene);
 else
     
 end
diff --git a/plotly/plotlyfig_aux/core/updateData.m b/plotly/plotlyfig_aux/core/updateData.m
index 1d0c8327..6b0c76ee 100644
--- a/plotly/plotlyfig_aux/core/updateData.m
+++ b/plotly/plotlyfig_aux/core/updateData.m
@@ -19,6 +19,8 @@
             updateLineseries(obj, dataIndex);
         elseif strcmpi(obj.PlotOptions.TreatAs, 'ezpolar')
             updateLineseries(obj, dataIndex);
+        elseif strcmpi(obj.PlotOptions.TreatAs, 'streamtube')
+            updateStreamtube(obj, dataIndex);
         end
         
     %-update plot based on plot call class-%
diff --git a/plotly/plotlyfig_aux/handlegraphics/updateContourProjection.m b/plotly/plotlyfig_aux/handlegraphics/updateContourProjection.m
index 6ad5051c..e53bf56c 100644
--- a/plotly/plotlyfig_aux/handlegraphics/updateContourProjection.m
+++ b/plotly/plotlyfig_aux/handlegraphics/updateContourProjection.m
@@ -10,7 +10,7 @@
 axis_data = get(obj.State.Plot(contourIndex).AssociatedAxis);
 
 %-PLOT DATA STRUCTURE- %
-contour_data = get(obj.State.Plot(contourIndex).Handle)
+contour_data = get(obj.State.Plot(contourIndex).Handle);
 
 %-CHECK FOR MULTIPLE AXES-%
 [xsource, ysource] = findSourceAxis(obj,axIndex);
@@ -40,68 +40,29 @@
 xdata = contour_data.XData;
 ydata = contour_data.YData;
 zdata = contour_data.ZData;
-
-if isvector(zdata)
-    
-    %-contour type-%
-    obj.data{contourIndex}.type = 'contour';
     
-    %-contour x data-%
-    if ~isvector(x)
-        obj.data{contourIndex}.xdata = xdata(1,:);
-    else
-        obj.data{contourIndex}.xdata = xdata;
-    end
+%-contour type-%
+obj.data{contourIndex}.type = 'surface';
 
-    %-contour y data-%
-    if ~isvector(y)
-        obj.data{contourIndex}.ydata = ydata';
-    else
-        obj.data{contourIndex}.ydata = ydata';
-    end
-    
-    %-contour z data-%
-    obj.data{contourIndex}.z = zdata;
-    
-else
-    
-    %-contour type-%
-    obj.data{contourIndex}.type = 'surface';
-    
-    %-contour x and y data
-%     [xmesh, ymesh] = meshgrid(xdata, ydata);
-    obj.data{contourIndex}.x = xdata;
-    obj.data{contourIndex}.y = ydata;
-    
-    %-contour z data-%
-    obj.data{contourIndex}.z = zdata;%-2*ones(size(zdata));
-    
-    %-setting for contour lines z-direction-%
-    obj.data{contourIndex}.contours.z.start = contour_data.LevelList(1);
-    obj.data{contourIndex}.contours.z.end = contour_data.LevelList(end);
-    obj.data{contourIndex}.contours.z.size = contour_data.LevelStep;
-    obj.data{contourIndex}.contours.z.show = true;
-    obj.data{contourIndex}.contours.z.usecolormap = true;
-    obj.data{contourIndex}.hidesurface = true;
-    obj.data{contourIndex}.surfacecolor = zdata;
-    
-    obj.data{contourIndex}.contours.z.project.x = true;
-    obj.data{contourIndex}.contours.z.project.y = true;
-    obj.data{contourIndex}.contours.z.project.z = true;
-    
-end
+%-contour x and y data
+obj.data{contourIndex}.x = xdata;
+obj.data{contourIndex}.y = ydata;
 
-%-------------------------------------------------------------------------%
+%-contour z data-%
+obj.data{contourIndex}.z = zdata;%-2*ones(size(zdata));
 
-%-contour x type-%
+%-setting for contour lines z-direction-%
+obj.data{contourIndex}.contours.z.start = contour_data.LevelList(1);
+obj.data{contourIndex}.contours.z.end = contour_data.LevelList(end);
+obj.data{contourIndex}.contours.z.size = contour_data.LevelStep;
+obj.data{contourIndex}.contours.z.show = true;
+obj.data{contourIndex}.contours.z.usecolormap = true;
+obj.data{contourIndex}.hidesurface = true;
+obj.data{contourIndex}.surfacecolor = zdata;
 
-obj.data{contourIndex}.xtype = 'array';
-
-%-------------------------------------------------------------------------%
-
-%-contour y type-%
-
-obj.data{contourIndex}.ytype = 'array';
+obj.data{contourIndex}.contours.z.project.x = true;
+obj.data{contourIndex}.contours.z.project.y = true;
+obj.data{contourIndex}.contours.z.project.z = true;
 
 %-------------------------------------------------------------------------%
 
@@ -116,21 +77,6 @@
 
 %-------------------------------------------------------------------------%
 
-%-zauto-%
-obj.data{contourIndex}.zauto = false;
-
-%-------------------------------------------------------------------------%
-
-%-zmin-%
-obj.data{contourIndex}.zmin = axis_data.CLim(1);
-
-%-------------------------------------------------------------------------%
-
-%-zmax-%
-obj.data{contourIndex}.zmax = axis_data.CLim(2);
-
-%-------------------------------------------------------------------------%
-
 %-colorscale (ASSUMES PATCH CDATAMAP IS 'SCALED')-%
 colormap = figure_data.Colormap;
 
@@ -144,69 +90,53 @@
 %-contour reverse scale-%
 obj.data{contourIndex}.reversescale = false;
 
-%-------------------------------------------------------------------------%
-
-%-autocontour-%
-obj.data{contourIndex}.autocontour = false;
+%---------------------------------------------------------------------%
 
-%-------------------------------------------------------------------------%
+%-aspect ratio-%
+ar = obj.PlotOptions.AspectRatio;
 
-%-contour contours-%
+if ~isempty(ar)
+    if ischar(ar)
+        obj.layout.scene.aspectmode = ar;
+    elseif isvector(ar) && length(ar) == 3
+        xar = ar(1);
+        yar = ar(2);
+        zar = ar(3);
+    end
+else
 
-%-coloring-%
-switch contour_data.Fill
-    case 'off'
-        obj.data{contourIndex}.contours.coloring = 'lines';
-    case 'on'
-        obj.data{contourIndex}.contours.coloring = 'fill';
+    %-define as default-%
+    xar = max(xdata(:));
+    yar = max(ydata(:));
+    xyar = max([xar, yar]);
+    zar = 0.6*xyar;
 end
 
-%-start-%
-obj.data{contourIndex}.contours.start = contour_data.TextList(1);
+obj.layout.scene.aspectratio.x = xyar;
+obj.layout.scene.aspectratio.y = xyar;
+obj.layout.scene.aspectratio.z = zar;
 
-%-end-%
-obj.data{contourIndex}.contours.end = contour_data.TextList(end);
+%---------------------------------------------------------------------%
 
-%-step-%
-obj.data{contourIndex}.contours.size = diff(contour_data.TextList(1:2));
+%-camera eye-%
+ey = obj.PlotOptions.CameraEye;
 
-%-------------------------------------------------------------------------%
-
-if(~strcmp(contour_data.LineStyle,'none'))
-    
-    %-contour line colour-%
-    if isnumeric(contour_data.LineColor)
-        col = 255*contour_data.LineColor;
-        obj.data{contourIndex}.line.color = ['rgb(' num2str(col(1)) ',' num2str(col(2)) ',' num2str(col(3)) ')'];
-    else
-        obj.data{contourIndex}.line.color = 'rgba(0,0,0,0)';
-    end
-    
-    %-contour line width-%
-    obj.data{contourIndex}.line.width = contour_data.LineWidth;
-    
-    %-contour line dash-%
-    switch contour_data.LineStyle
-        case '-'
-            LineStyle = 'solid';
-        case '--'
-            LineStyle = 'dash';
-        case ':'
-            LineStyle = 'dot';
-        case '-.'
-            LineStyle = 'dashdot';
+if ~isempty(ey)
+    if isvector(ey) && length(ey) == 3
+        obj.layout.scene.camera.eye.x = ey(1);
+        obj.layout.scene.camera.eye.y = ey(2);
+        obj.layout.scene.camera.eye.z = ey(3);
     end
-    
-    obj.data{contourIndex}.line.dash = LineStyle;
-    
-    %-contour smoothing-%
-    obj.data{contourIndex}.line.smoothing = 0;
-    
 else
+
+    %-define as default-%
+    xey = - xyar; if xey>0 xfac = -0.2; else xfac = 0.2; end
+    yey = - xyar; if yey>0 yfac = -0.2; else yfac = 0.2; end
+    if zar>0 zfac = 0.2; else zfac = -0.2; end
     
-    %-contours showlines-%
-    obj.data{contourIndex}.contours.showlines = false;
-    
+    obj.layout.scene.camera.eye.x = xey + xfac*xey; 
+    obj.layout.scene.camera.eye.y = yey + yfac*yey;
+    obj.layout.scene.camera.eye.z = zar + zfac*zar;
 end
 
 %-------------------------------------------------------------------------%
diff --git a/plotly/plotlyfig_aux/handlegraphics/updatePie3.m b/plotly/plotlyfig_aux/handlegraphics/updatePie3.m
index 60d94f50..c5ad57c8 100644
--- a/plotly/plotlyfig_aux/handlegraphics/updatePie3.m
+++ b/plotly/plotlyfig_aux/handlegraphics/updatePie3.m
@@ -6,34 +6,37 @@ function updatePie3(obj,plotIndex)
     else
         updateSurfacePie3(obj, plotIndex);
     end
-    
+
     %-hide axis-x-%
-    obj.layout.scene.xaxis.title = '';
-    obj.layout.scene.xaxis.autotick = false;
-    obj.layout.scene.xaxis.zeroline = false;
-    obj.layout.scene.xaxis.showline = false;
-    obj.layout.scene.xaxis.showticklabels = false;
-    obj.layout.scene.xaxis.showgrid = false;
+    obj.PlotOptions.scene.xaxis.title = '';
+    obj.PlotOptions.scene.xaxis.autotick = false;
+    obj.PlotOptions.scene.xaxis.zeroline = false;
+    obj.PlotOptions.scene.xaxis.showline = false;
+    obj.PlotOptions.scene.xaxis.showticklabels = false;
+    obj.PlotOptions.scene.xaxis.showgrid = false;
     
     %-hide axis-y-%
-    obj.layout.scene.yaxis.title = '';
-    obj.layout.scene.yaxis.autotick = false;
-    obj.layout.scene.yaxis.zeroline = false;
-    obj.layout.scene.yaxis.showline = false;
-    obj.layout.scene.yaxis.showticklabels = false;
-    obj.layout.scene.yaxis.showgrid = false;
+    obj.PlotOptions.scene.yaxis.title = '';
+    obj.PlotOptions.scene.yaxis.autotick = false;
+    obj.PlotOptions.scene.yaxis.zeroline = false;
+    obj.PlotOptions.scene.yaxis.showline = false;
+    obj.PlotOptions.scene.yaxis.showticklabels = false;
+    obj.PlotOptions.scene.yaxis.showgrid = false;
     
     %-hide axis-z-%
-    obj.layout.scene.zaxis.title = '';
-    obj.layout.scene.zaxis.autotick = false;
-    obj.layout.scene.zaxis.zeroline = false;
-    obj.layout.scene.zaxis.showline = false;
-    obj.layout.scene.zaxis.showticklabels = false;
-    obj.layout.scene.zaxis.showgrid = false;
+    obj.PlotOptions.scene.zaxis.title = '';
+    obj.PlotOptions.scene.zaxis.autotick = false;
+    obj.PlotOptions.scene.zaxis.zeroline = false;
+    obj.PlotOptions.scene.zaxis.showline = false;
+    obj.PlotOptions.scene.zaxis.showticklabels = false;
+    obj.PlotOptions.scene.zaxis.showgrid = false;
     
     %-put text-%
     obj.data{plotIndex}.hoverinfo = 'text';
     obj.data{plotIndex}.hovertext = obj.PlotOptions.perc;
+
+    obj.layout = setfield(obj.layout,['scene' obj.PlotOptions.scene_anchor(end)], obj.PlotOptions.scene);
+    obj.data{plotIndex}.scene = obj.PlotOptions.scene_anchor;
     
 end
 
@@ -42,285 +45,317 @@ function updatePie3(obj,plotIndex)
 
 function obj = updatePatchPie3(obj, patchIndex)
 
-%-AXIS INDEX-%
-axIndex = obj.getAxisIndex(obj.State.Plot(patchIndex).AssociatedAxis);
-
-%-PATCH DATA STRUCTURE- %
-patch_data = get(obj.State.Plot(patchIndex).Handle);
-
-%-get the percentage-%
-if ~any(nonzeros(patch_data.ZData))
-    t1 = atan2(patch_data.YData(2), patch_data.XData(2));
-    t2 = atan2(patch_data.YData(end-1), patch_data.XData(end-1));
-    
-    a = rad2deg(t2-t1);
-    if a < 0
-        a = a+360;
-    end
-    
-    obj.PlotOptions.perc = sprintf('%d %%', round(100*a/360));
-end
-
-%-CHECK FOR MULTIPLE AXES-%
-[xsource, ysource] = findSourceAxis(obj,axIndex);
-
-%-AXIS DATA-%
-eval(['xaxis = obj.layout.xaxis' num2str(xsource) ';']);
-eval(['yaxis = obj.layout.yaxis' num2str(ysource) ';']);
-
-%-------------------------------------------------------------------------%
-
-%-patch xaxis-%
-obj.data{patchIndex}.xaxis = ['x' num2str(xsource)];
-
-%-------------------------------------------------------------------------%
-
-%-patch yaxis-%
-obj.data{patchIndex}.yaxis = ['y' num2str(ysource)];
-
-%-------------------------------------------------------------------------%
-
-%-patch type-%
-obj.data{patchIndex}.type = 'scatter3d';
-
-%-------------------------------------------------------------------------%
-
-%-patch x-%
-xdata = patch_data.XData;
-if isvector(xdata)
-    obj.data{patchIndex}.x = [xdata' xdata(1)];
-else
-    xtemp = reshape(xdata,[],1);
-    xnew = [];
-    for n = 1:size(xdata,2)
-        xnew = [xnew ; xdata(:,n) ; xdata(1,n); NaN];
-    end
-    obj.data{patchIndex}.x = xnew;
-end
-
-%---------------------------------------------------------------------%
-
-%-patch y-%
-ydata = patch_data.YData;
-if isvector(ydata)
-    obj.data{patchIndex}.y = [ydata' ydata(1)];
-else
-    ytemp = reshape(ydata,[],1);
-    ynew = [];
-    for n = 1:size(ydata,2)
-        ynew = [ynew ; ydata(:,n) ; ydata(1,n); NaN];
-    end
-    obj.data{patchIndex}.y = ynew;
-end
-
-%---------------------------------------------------------------------%
-
-%-patch z-%
-zdata = patch_data.ZData;
-
-if isvector(ydata)
-    obj.data{patchIndex}.z = [zdata' zdata(1)];
-else
-    ztemp = reshape(zdata,[],1);
-    znew = [];
-    for n = 1:size(zdata,2)
-        znew = [znew ; zdata(:,n) ; zdata(1,n); NaN];
-    end
-    obj.data{patchIndex}.z = znew;
-end
-
-%---------------------------------------------------------------------%
-
-%-patch name-%
-if ~isempty(patch_data.DisplayName)
-    obj.data{patchIndex}.name = patch_data.DisplayName;
-else
-    obj.data{patchIndex}.name = patch_data.DisplayName;
-end
-
-%---------------------------------------------------------------------%
+  %-AXIS INDEX-%
+  axIndex = obj.getAxisIndex(obj.State.Plot(patchIndex).AssociatedAxis);
+
+  %-PATCH DATA STRUCTURE- %
+  patch_data = get(obj.State.Plot(patchIndex).Handle);
+
+  %-get the percentage-%
+  if ~any(nonzeros(patch_data.ZData))
+      t1 = atan2(patch_data.YData(2), patch_data.XData(2));
+      t2 = atan2(patch_data.YData(end-1), patch_data.XData(end-1));
+      
+      a = rad2deg(t2-t1);
+      if a < 0
+          a = a+360;
+      end
+      
+      obj.PlotOptions.perc = sprintf('%d %%', round(100*a/360));
+  end
+
+  %-CHECK FOR MULTIPLE AXES-%
+  [xsource, ysource] = findSourceAxis(obj,axIndex);
+
+  %-AXIS DATA-%
+  eval(['scene = obj.layout.scene' num2str(xsource) ';']);
+  obj.PlotOptions.scene_anchor = ['scene' num2str(xsource)];
+
+  %-------------------------------------------------------------------------%
+
+  %-scene to be set-%
+  obj.PlotOptions.scene = scene;
+
+  %-------------------------------------------------------------------------%
+
+  %-patch type-%
+  obj.data{patchIndex}.type = 'scatter3d';
+
+  %-------------------------------------------------------------------------%
+
+  %-patch x-%
+  xdata = patch_data.XData;
+  if isvector(xdata)
+      obj.data{patchIndex}.x = [xdata' xdata(1)];
+  else
+      xtemp = reshape(xdata,[],1);
+      xnew = [];
+      for n = 1:size(xdata,2)
+          xnew = [xnew ; xdata(:,n) ; xdata(1,n); NaN];
+      end
+      obj.data{patchIndex}.x = xnew;
+  end
+
+  %---------------------------------------------------------------------%
+
+  %-patch y-%
+  ydata = patch_data.YData;
+  if isvector(ydata)
+      obj.data{patchIndex}.y = [ydata' ydata(1)];
+  else
+      ytemp = reshape(ydata,[],1);
+      ynew = [];
+      for n = 1:size(ydata,2)
+          ynew = [ynew ; ydata(:,n) ; ydata(1,n); NaN];
+      end
+      obj.data{patchIndex}.y = ynew;
+  end
+
+  %---------------------------------------------------------------------%
+
+  %-patch z-%
+  zdata = patch_data.ZData;
+
+  if isvector(ydata)
+      obj.data{patchIndex}.z = [zdata' zdata(1)];
+  else
+      ztemp = reshape(zdata,[],1);
+      znew = [];
+      for n = 1:size(zdata,2)
+          znew = [znew ; zdata(:,n) ; zdata(1,n); NaN];
+      end
+      obj.data{patchIndex}.z = znew;
+  end
+
+  %---------------------------------------------------------------------%
+
+  %-patch name-%
+  if ~isempty(patch_data.DisplayName)
+      obj.data{patchIndex}.name = patch_data.DisplayName;
+  else
+      obj.data{patchIndex}.name = patch_data.DisplayName;
+  end
+
+  %---------------------------------------------------------------------%
+
+  %-patch visible-%
+  obj.data{patchIndex}.visible = strcmp(patch_data.Visible,'on');
+
+  %---------------------------------------------------------------------%
+
+  %-patch fill-%
+  %     obj.data{patchIndex}.fill = 'tozeroy';
+
+  %-PATCH MODE-%
+  if ~strcmpi('none', patch_data.Marker) && ~strcmpi('none', patch_data.LineStyle)
+      mode = 'lines+markers';
+  elseif ~strcmpi('none', patch_data.Marker)
+      mode = 'markers';
+  elseif ~strcmpi('none', patch_data.LineStyle)
+      mode = 'lines';
+  else
+      mode = 'none';
+  end
+
+  obj.data{patchIndex}.mode = mode;
+
+  %---------------------------------------------------------------------%
+
+  %-patch marker-%
+  obj.data{patchIndex}.marker = extractPatchMarker(patch_data);
 
-%-patch visible-%
-obj.data{patchIndex}.visible = strcmp(patch_data.Visible,'on');
+  %---------------------------------------------------------------------%
+
+  %-patch line-%
+  obj.data{patchIndex}.line = extractPatchLine(patch_data);
+
+  %---------------------------------------------------------------------%
 
-%---------------------------------------------------------------------%
+  %-patch fillcolor-%
+  fill = extractPatchFace(patch_data);
+
+  if strcmp(obj.data{patchIndex}.type,'scatter')
+      obj.data{patchIndex}.fillcolor = fill.color; 
+  else
+      obj.data{patchIndex}.surfacecolor = fill.color;
+  end
+
+  %---------------------------------------------------------------------%
+
+  %-surfaceaxis-%
+  if strcmp(obj.data{patchIndex}.type,'scatter3d')
+      minstd = min([std(patch_data.XData) std(patch_data.YData) std(patch_data.ZData)]);
+      ind = find([std(patch_data.XData) std(patch_data.YData) std(patch_data.ZData)] == minstd)-1;
+      obj.data{patchIndex}.surfaceaxis = ind; 
+  end
+
+  %-------------------------------------------------------------------------%
+
+  %-patch showlegend-%
+  leg = get(patch_data.Annotation);
+  legInfo = get(leg.LegendInformation);
 
-%-patch fill-%
-%     obj.data{patchIndex}.fill = 'tozeroy';
+  switch legInfo.IconDisplayStyle
+      case 'on'
+          showleg = true;
+      case 'off'
+          showleg = false;
+  end
+
+  obj.data{patchIndex}.showlegend = showleg;
 
-%-PATCH MODE-%
-if ~strcmpi('none', patch_data.Marker) && ~strcmpi('none', patch_data.LineStyle)
-    mode = 'lines+markers';
-elseif ~strcmpi('none', patch_data.Marker)
-    mode = 'markers';
-elseif ~strcmpi('none', patch_data.LineStyle)
-    mode = 'lines';
-else
-    mode = 'none';
-end
-
-obj.data{patchIndex}.mode = mode;
-
-%---------------------------------------------------------------------%
-
-%-patch marker-%
-obj.data{patchIndex}.marker = extractPatchMarker(patch_data);
-
-%---------------------------------------------------------------------%
-
-%-patch line-%
-obj.data{patchIndex}.line = extractPatchLine(patch_data);
-
-%---------------------------------------------------------------------%
-
-%-patch fillcolor-%
-fill = extractPatchFace(patch_data);
-
-if strcmp(obj.data{patchIndex}.type,'scatter')
-    obj.data{patchIndex}.fillcolor = fill.color; 
-else
-    obj.data{patchIndex}.surfacecolor = fill.color;
-end
-
-%---------------------------------------------------------------------%
-
-%-surfaceaxis-%
-if strcmp(obj.data{patchIndex}.type,'scatter3d')
-    minstd = min([std(patch_data.XData) std(patch_data.YData) std(patch_data.ZData)]);
-    ind = find([std(patch_data.XData) std(patch_data.YData) std(patch_data.ZData)] == minstd)-1;
-    obj.data{patchIndex}.surfaceaxis = ind; 
-end
-
-%-------------------------------------------------------------------------%
-
-%-patch showlegend-%
-leg = get(patch_data.Annotation);
-legInfo = get(leg.LegendInformation);
-
-switch legInfo.IconDisplayStyle
-    case 'on'
-        showleg = true;
-    case 'off'
-        showleg = false;
-end
-
-obj.data{patchIndex}.showlegend = showleg;
-
-%-------------------------------------------------------------------------%
+  %-------------------------------------------------------------------------%
 end
 
 
 
 function obj = updateSurfacePie3(obj, surfaceIndex)
 
-%-AXIS INDEX-%
-axIndex = obj.getAxisIndex(obj.State.Plot(surfaceIndex).AssociatedAxis);
-
-%-CHECK FOR MULTIPLE AXES-%
-[xsource, ysource] = findSourceAxis(obj,axIndex);
-
-%-SURFACE DATA STRUCTURE- %
-image_data = get(obj.State.Plot(surfaceIndex).Handle);
-figure_data = get(obj.State.Figure.Handle);
-
-%-AXIS DATA-%
-eval(['xaxis = obj.layout.xaxis' num2str(xsource) ';']);
-eval(['yaxis = obj.layout.yaxis' num2str(ysource) ';']);
+  %-AXIS INDEX-%
+  axIndex = obj.getAxisIndex(obj.State.Plot(surfaceIndex).AssociatedAxis);
+
+  %-CHECK FOR MULTIPLE AXES-%
+  [xsource, ysource] = findSourceAxis(obj,axIndex);
+
+  %-SURFACE DATA STRUCTURE- %
+  image_data = get(obj.State.Plot(surfaceIndex).Handle);
+  figure_data = get(obj.State.Figure.Handle);
+
+  %-AXIS DATA-%
+  eval(['scene = obj.layout.scene' num2str(xsource) ';']);
+  obj.PlotOptions.scene_anchor = ['scene' num2str(xsource)];
+
+  %-------------------------------------------------------------------------%
+      
+  %-surface type-%
+  obj.data{surfaceIndex}.type = 'surface';
+  
+  %------------------------------------------------------------------------%
+  
+  %-surface x-%
+  obj.data{surfaceIndex}.x = image_data.XData;
+
+  %------------------------------------------------------------------------%
+  
+  %-surface y-%
+  obj.data{surfaceIndex}.y = image_data.YData;
+  
+  %------------------------------------------------------------------------%
+  
+  %-surface z-%
+  obj.data{surfaceIndex}.z = image_data.ZData;
+  
+  %------------------------------------------------------------------------%
+
+  %-image colorscale-%
+
+  cmap = figure_data.Colormap;
+  len = length(cmap)-1;
+
+  for c = 1:length(cmap)
+      col = 255 * cmap(c, :);
+      obj.data{surfaceIndex}.colorscale{c} = { (c-1)/len , ['rgb(' num2str(col(1)) ',' num2str(col(2)) ',' num2str(col(3)) ')'  ]  };
+  end
+
+  obj.data{surfaceIndex}.surfacecolor = 255*(image_data.CData-1) / (obj.PlotOptions.nbars{xsource} - 1);
+  obj.data{surfaceIndex}.cmax = 255;
+  obj.data{surfaceIndex}.cmin = 0;
+
+  %------------------------------------------------------------------------%
+
+  %-get data-%
+  xdata = image_data.XData;
+  ydata = image_data.YData;
+
+  %-aspect ratio-%
+  ar = obj.PlotOptions.AspectRatio;
+
+  if ~isempty(ar)
+      if ischar(ar)
+          scene.aspectmode = ar;
+      elseif isvector(ar) && length(ar) == 3
+          xar = ar(1);
+          yar = ar(2);
+          zar = ar(3);
+      end
+  else
+
+      %-define as default-%
+      xar = max(xdata(:));
+      yar = max(ydata(:));
+      zar = max([xar, yar]);
+  end
+
+  fac1 = 0.75;
+  fac2 = 0.175;
+  nax = length(obj.PlotOptions.nbars);
+
+  scene.aspectratio.x = xar + fac1*(nax-1)*xar; 
+  scene.aspectratio.y = yar + fac1*(nax-1)*yar; 
+  scene.aspectratio.z = (zar + fac1*(nax-1)*zar)*fac2; 
+
+  % optional equations
+  % scene.aspectratio.x = xar*(1+fac1); 
+  % scene.aspectratio.y = yar*(1+fac1); 
+  % scene.aspectratio.z = zar*fac2*(1+fac1); 
+
+  %---------------------------------------------------------------------%
+
+  %-camera eye-%
+  ey = obj.PlotOptions.CameraEye;
+
+  if ~isempty(ey)
+      if isvector(ey) && length(ey) == 3
+          scene.camera.eye.x = ey(1);
+          scene.camera.eye.y = ey(2);
+          scene.camera.eye.z = ey(3);
+      end
+  else
+
+      %-define as default-%
+      xey = - xar; if xey>0 xfac = -0.2; else xfac = 0.2; end
+      yey = - yar; if yey>0 yfac = -0.2; else yfac = 0.2; end
+      if zar>0 zfac = 0.2; else zfac = -0.2; end
+      
+      scene.camera.eye.x = xey + xfac*xey; 
+      scene.camera.eye.y = yey + yfac*yey;
+      scene.camera.eye.z = zar + zfac*zar;
+  end
+
+  %-------------------------------------------------------------------------%
+
+  %-scene to be set-%
+  obj.PlotOptions.scene = scene;
+
+  %-------------------------------------------------------------------------%
+
+  %-surface name-%
+  obj.data{surfaceIndex}.name = image_data.DisplayName;
+
+  %-------------------------------------------------------------------------%
+
+  %-surface showscale-%
+  obj.data{surfaceIndex}.showscale = false;
+
+  %-------------------------------------------------------------------------%
 
-%-------------------------------------------------------------------------%
+  %-surface visible-%
+  obj.data{surfaceIndex}.visible = strcmp(image_data.Visible,'on');
 
-%-surface xaxis-%
-obj.data{surfaceIndex}.xaxis = ['x' num2str(xsource)];
+  %-------------------------------------------------------------------------%
 
-%-------------------------------------------------------------------------%
-
-%-surface yaxis-%
-obj.data{surfaceIndex}.yaxis = ['y' num2str(ysource)];
-
-%-------------------------------------------------------------------------%
-
-% check for 3D
-if any(nonzeros(image_data.ZData))
-    
-    %-surface type-%
-    obj.data{surfaceIndex}.type = 'surface';
-    
-    %---------------------------------------------------------------------%
-    
-    %-surface x-%
-    obj.data{surfaceIndex}.x = image_data.XData;
-
-    %---------------------------------------------------------------------%
-    
-    %-surface y-%
-    obj.data{surfaceIndex}.y = image_data.YData;
-    
-    %---------------------------------------------------------------------%
-    
-    %-surface z-%
-    obj.data{surfaceIndex}.z = image_data.ZData;
-    
-    %---------------------------------------------------------------------%
-    
-else
-    
-    %-surface type-%
-    obj = updateImage(obj, surfaceIndex);
-    
-    %-surface x-%
-    obj.data{surfaceIndex}.x = image_data.XData(1,:);
-    
-    %-surface y-%
-    obj.data{surfaceIndex}.y = image_data.YData(:,1);
-end
-
-%-------------------------------------------------------------------------%
-
-%-image colorscale-%
-
-cmap = figure_data.Colormap;
-len = length(cmap)-1;
-
-for c = 1:length(cmap)
-    col = 255 * cmap(c, :);
-    obj.data{surfaceIndex}.colorscale{c} = { (c-1)/len , ['rgb(' num2str(col(1)) ',' num2str(col(2)) ',' num2str(col(3)) ')'  ]  };
-end
-
-obj.data{surfaceIndex}.surfacecolor = 255*(image_data.CData-1) / obj.PlotOptions.nbars;
-obj.data{surfaceIndex}.cmax = 255;
-obj.data{surfaceIndex}.cmin = 0;
-obj.layout.scene.aspectmode = 'data';
-
-%-------------------------------------------------------------------------%
-
-%-surface name-%
-obj.data{surfaceIndex}.name = image_data.DisplayName;
-
-%-------------------------------------------------------------------------%
-
-%-surface showscale-%
-obj.data{surfaceIndex}.showscale = false;
-
-%-------------------------------------------------------------------------%
-
-%-surface visible-%
-obj.data{surfaceIndex}.visible = strcmp(image_data.Visible,'on');
-
-%-------------------------------------------------------------------------%
-
-leg = get(image_data.Annotation);
-legInfo = get(leg.LegendInformation);
-
-switch legInfo.IconDisplayStyle
-    case 'on'
-        showleg = true;
-    case 'off'
-        showleg = false;
-end
+  leg = get(image_data.Annotation);
+  legInfo = get(leg.LegendInformation);
 
-obj.data{surfaceIndex}.showlegend = showleg;
+  switch legInfo.IconDisplayStyle
+      case 'on'
+          showleg = true;
+      case 'off'
+          showleg = false;
+  end
 
-%-------------------------------------------------------------------------%
+  obj.data{surfaceIndex}.showlegend = showleg;
 
+  %-------------------------------------------------------------------------%
 end
 
diff --git a/plotly/plotlyfig_aux/handlegraphics/updateStreamtube.m b/plotly/plotlyfig_aux/handlegraphics/updateStreamtube.m
new file mode 100644
index 00000000..f19ab522
--- /dev/null
+++ b/plotly/plotlyfig_aux/handlegraphics/updateStreamtube.m
@@ -0,0 +1,156 @@
+function obj = updateStreamtube(obj, surfaceIndex)
+if strcmpi(obj.State.Plot(surfaceIndex).Class, 'surface')
+    updateSurfaceStreamtube(obj, surfaceIndex)
+end
+end
+
+function updateSurfaceStreamtube(obj, surfaceIndex)
+
+%-AXIS INDEX-%
+axIndex = obj.getAxisIndex(obj.State.Plot(surfaceIndex).AssociatedAxis);
+
+%-CHECK FOR MULTIPLE AXES-%
+[xsource, ysource] = findSourceAxis(obj,axIndex);
+
+%-SURFACE DATA STRUCTURE- %
+image_data = get(obj.State.Plot(surfaceIndex).Handle);
+figure_data = get(obj.State.Figure.Handle);
+
+%-AXIS DATA-%
+eval(['xaxis = obj.layout.xaxis' num2str(xsource) ';']);
+eval(['yaxis = obj.layout.yaxis' num2str(ysource) ';']);
+
+%-------------------------------------------------------------------------%
+
+%-surface xaxis-%
+obj.data{surfaceIndex}.xaxis = ['x' num2str(xsource)];
+
+%-------------------------------------------------------------------------%
+
+%-surface yaxis-%
+obj.data{surfaceIndex}.yaxis = ['y' num2str(ysource)];
+
+    
+%---------------------------------------------------------------------%
+
+%-surface type-%
+obj.data{surfaceIndex}.type = 'surface';
+
+%---------------------------------------------------------------------%
+
+%-format x an y data-%
+ymax = 100;
+x = image_data.XData;
+y = image_data.YData;
+z = image_data.ZData;
+cdata = image_data.CData;
+
+ysize = size(x,1);
+xsize = size(x,2);
+
+if ysize > ymax
+    ystep = round(ysize/ymax);
+    x = x(1:ystep:end, :);
+    y = y(1:ystep:end, :);
+    z = z(1:ystep:end, :);
+    cdata = cdata(1:ystep:end, :);
+end 
+
+if isvector(x)
+    [x, y] = meshgrid(x,y);
+end
+
+%---------------------------------------------------------------------%
+
+%-surface x-%
+obj.data{surfaceIndex}.x = x;
+
+%---------------------------------------------------------------------%
+
+%-surface y-%
+obj.data{surfaceIndex}.y = y;
+
+%---------------------------------------------------------------------%
+
+%-surface z-%
+obj.data{surfaceIndex}.z = z;
+
+%---------------------------------------------------------------------%
+
+%-if image comes would a 3D plot-%
+obj.PlotOptions.Image3D = true;
+
+%-if contour comes would a ContourProjection-%
+obj.PlotOptions.ContourProjection = true;
+
+%---------------------------------------------------------------------%
+
+%- setting grid mesh by default -%
+% x-direction
+xmin = min(x(:));
+xmax = max(x(:));
+xsize = (xmax - xmin) / (size(x, 2)-1); 
+obj.data{surfaceIndex}.contours.x.start = xmin;
+obj.data{surfaceIndex}.contours.x.end = xmax;
+obj.data{surfaceIndex}.contours.x.size = xsize;
+obj.data{surfaceIndex}.contours.x.show = true;
+obj.data{surfaceIndex}.contours.x.color = 'black';
+% y-direction
+ymin = min(y(:));
+ymax = max(y(:));
+ysize = (ymax - ymin) / (size(y, 1)-1);
+obj.data{surfaceIndex}.contours.y.start = ymin;
+obj.data{surfaceIndex}.contours.y.end = ymax;
+obj.data{surfaceIndex}.contours.y.size = ysize;
+obj.data{surfaceIndex}.contours.y.show = true;
+obj.data{surfaceIndex}.contours.y.color = 'black';
+
+%-------------------------------------------------------------------------%
+
+%-image colorscale-%
+
+cmap = figure_data.Colormap;
+len = length(cmap)-1;
+
+for c = 1: length(cmap)
+    col = 255 * cmap(c, :);
+    obj.data{surfaceIndex}.colorscale{c} = { (c-1)/len , ['rgb(' num2str(col(1)) ',' num2str(col(2)) ',' num2str(col(3)) ')'  ]  };
+end
+
+%-------------------------------------------------------------------------%
+
+%-surface coloring-%
+obj.data{surfaceIndex}.surfacecolor = cdata;
+
+%-------------------------------------------------------------------------%
+
+%-surface name-%
+obj.data{surfaceIndex}.name = image_data.DisplayName;
+
+%-------------------------------------------------------------------------%
+
+%-surface showscale-%
+obj.data{surfaceIndex}.showscale = false;
+
+%-------------------------------------------------------------------------%
+
+%-surface visible-%
+obj.data{surfaceIndex}.visible = strcmp(image_data.Visible,'on');
+
+%-------------------------------------------------------------------------%
+
+leg = get(image_data.Annotation);
+legInfo = get(leg.LegendInformation);
+
+switch legInfo.IconDisplayStyle
+    case 'on'
+        showleg = true;
+    case 'off'
+        showleg = false;
+end
+
+obj.data{surfaceIndex}.showlegend = showleg;
+
+%-------------------------------------------------------------------------%
+
+end