diff --git a/GPy/core/mapping.py b/GPy/core/mapping.py
index 513407eb..ef0af16c 100644
--- a/GPy/core/mapping.py
+++ b/GPy/core/mapping.py
@@ -1,10 +1,9 @@
 # Copyright (c) 2013, GPy authors (see AUTHORS.txt).
 # Licensed under the BSD 3-clause license (see LICENSE.txt)
 
-from ..util.plot import Tango, x_frame1D, x_frame2D
+import sys
 from parameterization import Parameterized
 import numpy as np
-import pylab as pb
 
 class Mapping(Parameterized):
     """
@@ -47,11 +46,8 @@ class Mapping(Parameterized):
 
         raise NotImplementedError
 
-    def plot(self, plot_limits=None, which_data='all', which_parts='all', resolution=None, levels=20, samples=0, fignum=None, ax=None, fixed_inputs=[], linecol=Tango.colorsHex['darkBlue']):
+    def plot(self, *args):
         """
-
-        Plot the mapping.
-
         Plots the mapping associated with the model.
           - In one dimension, the function is plotted.
           - In two dimsensions, a contour-plot shows the function
@@ -60,68 +56,15 @@ class Mapping(Parameterized):
         Can plot only part of the data and part of the posterior functions
         using which_data and which_functions
 
-        :param plot_limits: The limits of the plot. If 1D [xmin,xmax], if 2D [[xmin,ymin],[xmax,ymax]]. Defaluts to data limits
-        :type plot_limits: np.array
-        :param which_data: which if the training data to plot (default all)
-        :type which_data: 'all' or a slice object to slice self.X, self.Y
-        :param which_parts: which of the kernel functions to plot (additively)
-        :type which_parts: 'all', or list of bools
-        :param resolution: the number of intervals to sample the GP on. Defaults to 200 in 1D and 50 (a 50x50 grid) in 2D
-        :type resolution: int
-        :param levels: number of levels to plot in a contour plot.
-        :type levels: int
-        :param samples: the number of a posteriori samples to plot
-        :type samples: int
-        :param fignum: figure to plot on.
-        :type fignum: figure number
-        :param ax: axes to plot on.
-        :type ax: axes handle
-        :param fixed_inputs: a list of tuple [(i,v), (i,v)...], specifying that input index i should be set to value v.
-        :type fixed_inputs: a list of tuples
-        :param linecol: color of line to plot.
-        :type linecol:
-        :param levels: for 2D plotting, the number of contour levels to use is ax is None, create a new figure
-
+        This is a convenience function: arguments are passed to GPy.plotting.matplot_dep.models_plots.plot_mapping
         """
-        # TODO include samples
-        if which_data == 'all':
-            which_data = slice(None)
-
-        if ax is None:
-            fig = pb.figure(num=fignum)
-            ax = fig.add_subplot(111)
-
-        plotdims = self.input_dim - len(fixed_inputs)
-
-        if plotdims == 1:
-
-            Xu = self.X * self._Xscale + self._Xoffset # NOTE self.X are the normalized values now
-
-            fixed_dims = np.array([i for i,v in fixed_inputs])
-            freedim = np.setdiff1d(np.arange(self.input_dim),fixed_dims)
-
-            Xnew, xmin, xmax = x_frame1D(Xu[:,freedim], plot_limits=plot_limits)
-            Xgrid = np.empty((Xnew.shape[0],self.input_dim))
-            Xgrid[:,freedim] = Xnew
-            for i,v in fixed_inputs:
-                Xgrid[:,i] = v
-
-            f = self.predict(Xgrid, which_parts=which_parts)
-            for d in range(y.shape[1]):
-                ax.plot(Xnew, f[:, d], edgecol=linecol)
-
-        elif self.X.shape[1] == 2:
-            resolution = resolution or 50
-            Xnew, _, _, xmin, xmax = x_frame2D(self.X, plot_limits, resolution)
-            x, y = np.linspace(xmin[0], xmax[0], resolution), np.linspace(xmin[1], xmax[1], resolution)
-            f = self.predict(Xnew, which_parts=which_parts)
-            m = m.reshape(resolution, resolution).T
-            ax.contour(x, y, f, levels, vmin=m.min(), vmax=m.max(), cmap=pb.cm.jet) # @UndefinedVariable
-            ax.set_xlim(xmin[0], xmax[0])
-            ax.set_ylim(xmin[1], xmax[1])
 
+        if "matplotlib" in sys.modules:
+            from ..plotting.matplot_dep import models_plots
+            mapping_plots.plot_mapping(self,*args)
         else:
-            raise NotImplementedError, "Cannot define a frame with more than two input dimensions"
+            raise NameError, "matplotlib package has not been imported."
+
 
 from model import Model
 
@@ -135,14 +78,14 @@ class Mapping_check_model(Model):
             X = np.random.randn(num_samples, mapping.input_dim)
         if dL_df==None:
             dL_df = np.ones((num_samples, mapping.output_dim))
-        
+
         self.mapping=mapping
         self.X = X
         self.dL_df = dL_df
         self.num_params = self.mapping.num_params
         Model.__init__(self)
 
-        
+
     def _get_params(self):
         return self.mapping._get_params()
 
@@ -157,7 +100,7 @@ class Mapping_check_model(Model):
 
     def _log_likelihood_gradients(self):
         raise NotImplementedError, "This needs to be implemented to use the Mapping_check_model class."
-    
+
 class Mapping_check_df_dtheta(Mapping_check_model):
     """This class allows gradient checks for the gradient of a mapping with respect to parameters. """
     def __init__(self, mapping=None, dL_df=None, X=None):
@@ -175,13 +118,13 @@ class Mapping_check_df_dX(Mapping_check_model):
         if dL_df==None:
             dL_df = np.ones((self.X.shape[0],self.mapping.output_dim))
         self.num_params = self.X.shape[0]*self.mapping.input_dim
-        
+
     def _log_likelihood_gradients(self):
         return self.mapping.df_dX(self.dL_df, self.X).flatten()
 
     def _get_param_names(self):
         return ['X_'  +str(i) + ','+str(j) for j in range(self.X.shape[1]) for i in range(self.X.shape[0])]
-                
+
     def _get_params(self):
         return self.X.flatten()