   {
     if (!transform_dirty) return;
     auto data=vtkDataSet::SafeDownCast(data_producer->GetOutputDataObject(0));
 
     if (  state.xmin<state.xmax 
           &&state.ymin<state.ymax
           &&(state.spacedim==2 || state.zmin<state.zmax))
     {
       data_bounds[0]=state.xmin;
       data_bounds[1]=state.xmax;
       data_bounds[2]=state.ymin;
       data_bounds[3]=state.ymax;
       data_bounds[4]=state.zmin;
       data_bounds[5]=state.zmax;
       data_center[0]=0.5*(data_bounds[0]+data_bounds[1]);
       data_center[1]=0.5*(data_bounds[2]+data_bounds[3]);
       data_center[2]=0.5*(data_bounds[4]+data_bounds[5]);
     }
     else if (data)
     {
       data->GetBounds(data_bounds);
       data->GetCenter(data_center);
     }
     else
     {
       throw std::runtime_error("Specify either view volume or dataset for figure\n");
     }
     if (!transform)
       transform =  vtkSmartPointer<vtkTransform>::New();
     transform->Identity();
     double xsize=data_bounds[1]-data_bounds[0];
     double ysize=data_bounds[3]-data_bounds[2];
     double zsize=data_bounds[5]-data_bounds[4];
     if (state.spacedim==2) zsize=0;
     double xysize=std::max(xsize,ysize);
     double xyzsize=std::max(xysize,zsize);
 
     // we don't need this if we prevent vectors from being
     // transformed 
     //state.quiver_arrowscale_geometry=1.0/xyzsize;
     
     // transform everything to [0,1]x[0,1]x[0,1]
     if (state.keep_aspect)
     {
       if (xsize>ysize)
         transform->Translate(0,0.5*(xsize-ysize)/xyzsize,0);
       else
         transform->Translate(0.5*(ysize-xsize)/xyzsize,0,0);
       
       transform->Scale(1.0/xyzsize, 1.0/xyzsize,1.0/xyzsize);
     }
     else
     {
       if (state.aspect>1.0)
       {
         transform->Translate(0,0.5-0.5/state.aspect,0);
         transform->Scale(1.0/xsize, 1.0/(state.aspect*ysize),1);
       }
       else
       {
         transform->Translate(0.5-0.5*state.aspect,0,0);
         transform->Scale(state.aspect/xsize, 1.0/ysize,1);
       }
     }
     
     transform->Translate(-data_bounds[0],-data_bounds[2],-data_bounds[4]);
   
     double p0[3]={data_bounds[0],data_bounds[2],data_bounds[4]};
     double p1[3]={data_bounds[1],data_bounds[3],data_bounds[5]};
     double tp0[3],tp1[3];
 
     transform->TransformPoint(p0,tp0);
     transform->TransformPoint(p1,tp1);
     trans_bounds[0]=tp0[0];
     trans_bounds[1]=tp1[0];
     trans_bounds[2]=tp0[1];
     trans_bounds[3]=tp1[1];
     trans_bounds[4]=tp0[2];
     trans_bounds[5]=tp1[2];
 
     transform->TransformPoint(data_center,trans_center);
     
     transform_dirty=false;
   }