Properties of axes objects (see axes):

Categories:
...........

Automatic Child Properties | Axes Box Appearance | Axes Grid Appearance | Callback Execution | Camera and View Controls | Color and Transparency | Creation/Deletion | Display | Mouse Interaction | Object Identification | Object Position | Parent/Children | Text Appearance

Automatic Child Properties
..........................

colororder: N-by-3 RGB matrix, def. 7-by-3 double
     RGB values used by plot function for child object coloring.

colororderindex: integer, def. 1
     Index of the next color from the "colororder" property to be used by Axes-child objects.

linestyleorder: def. "-"
     List of linestyles to be used in order by axes child objects, specified as a cell array of line specification strings.  Note that the linestyle is only incremented after cycling through the full "colororder" list.  See Line Styles.

linestyleorderindex: whole number scalar, def. 1
     Index of the next linestyle from the "linestyleorder" property to be used by Axes-child objects.

nextseriesindex (read-only): whole number scalar, def. 1
     Current index value into the "colororder" and "linestyleorder" properties, indicating the item that will be used by the next child object

Axes Box Appearance
...................

box: {"off"} | "on"
     Control whether the axes has a surrounding box.

boxstyle: {"back"} | "full"
     For 3-D axes, control whether the "full" box is drawn or only the 3 "back" axes.

color: colorspec, def. [1   1   1]
     Color of the axes background.  See colorspec.

dataaspectratio: three-element vector, def. [1   1   1]
     Specify the relative height and width of the data displayed in the axes.  Setting dataaspectratio to [1, 2] causes the length of one unit as displayed on the x-axis to be the same as the length of 2 units on the y-axis.  See daspect function.  Setting dataaspectratio also forces the dataaspectratiomode property to be set to "manual".

dataaspectratiomode: {"auto"} | "manual"
     Current state of the data aspect ratio mode, either manually set by the "dataaspectratio" property or automatically set by Octave in combination with other display properties to fit the data in the current view.

layer: {"bottom"} | "top"
     Control whether the axes is drawn below child graphics objects (ticks, labels, etc. covered by plotted objects) or above.

layout (read-only): def. [](0x0)
     Tiled and gridded chart layout is not yet implemented for axes objects.  layout is unused.

linewidth: scalar, def. 0.5000
     Width of the main axes lines.

tickdir: "both" | {"in"} | "none" | "out"
     Control whether axes tick marks project "in" to the plot box or "out".  The value "both" will draw tick marks both in and out.  The value "none" means no tick marks will be drawn, although tick labels will still be rendered.  Setting tickdir also forces the tickdirmode property to be set to "manual".  Note that the default is "in" for 2-D and "out" for 3-D plots.

tickdirmode: {"auto"} | "manual"
     Current state of the tickdir mode, either manually set by the "tickdir" property or automatically set to the default for the current view.

ticklength: two-element vector, def. [0.010000   0.025000]
     Two-element vector [2Dlen 3Dlen] specifying the length of the tickmarks relative to the longest visible axis.

toolbar (read-only): def. [](0x0)
     AxesToolbar objects is not yet implemented for axes objects.  toolbar is unused.

xaxis (read-only): def. [](0x0)
     Axes Ruler objects is not yet implemented for axes objects.  xaxis is unused.

xaxislocation: {"bottom"} | "origin" | "top"
     Control the x-axis location.

xcolor: {colorspec} | "none", def. [0.1500   0.1500   0.1500]
     Color of the x-axis.  See colorspec.  Setting xcolor also forces the xcolormode property to be set to "manual".

xcolormode: {"auto"} | "manual"
     Current state of the setting determining the color that is applied to the x-axis grid lines.  If set to "auto" and/or the "gridcolormode" property is set to "manual", the x-axis grid color will be defined by the "gridcolor" property.  Otherwise the x-axis grid color will be defined by the "xcolor" property.

xdir: {"normal"} | "reverse"
     Direction of the x axis: "normal" is left to right in default 2-D and 3-D views.

xlim: two-element vector, def. [0   1]
     Two-element vector [xmin xmax] specifying the limits for the x-axis.  Setting xlim also forces the xlimmode property to be set to "manual".   See xlim function.

xlimitmethod: "padded" | {"tickaligned"} | "tight"
     Method used to determine the x-axis limits when the xlimmode property is "auto".  The default value, "tickaligned" makes limits align with the closest ticks.  With value "tight" the limits are adjusted to enclose all the graphics objects in the axes, while with value "padded", an additional margin of about 7% of the data extent is added around the objects.  See axis function.

xlimmode: {"auto"} | "manual"
     Current state of the x-axis limit selection method, either manually set with the "xlim" property or automatically set to span the plotted data according to the "xlimitmethod" property.

xminortick: {"off"} | "on"
     Control whether minor x tick marks are displayed.

xtick: vector
     Position of x tick marks.  Setting xtick also forces the xtickmode property to be set to "manual".

xtickmode: {"auto"} | "manual"
     Setting to determine whether the xtick locations and spacing are set automatically by Octave or manually using the "xtick" property.

yaxis (read-only): def. [](0x0)
     Axes Ruler objects is not yet implemented for axes objects.  yaxis is unused.

yaxislocation: {"left"} | "origin" | "right"
     Control the y-axis location.

ycolor: {colorspec} | "none", def. [0.1500   0.1500   0.1500]
     Color of the y-axis.  See colorspec.

ycolormode: {"auto"} | "manual"
     Current state of the setting determining the color that is applied to the y-axis grid lines.  If set to "auto" and/or the "gridcolormode" property is set to "manual", the y-axis grid color will be defined by the "gridcolor" property.  Otherwise the y-axis grid color will be defined by the "ycolor" property.

ydir: {"normal"} | "reverse"
     Direction of the y-axis: "normal" is bottom to top in 2-D and front to back in 3-D default views.

ylim: two-element vector, def. [0   1]
     Two-element vector [ymin ymax] specifying the limits for the y-axis.  Setting ylim also forces the ylimmode property to be set to "manual".  See ylim function.

ylimitmethod: "padded" | {"tickaligned"} | "tight"
     Method used to determine the y-axis limits when the xlimmode property is "auto".  The default value, "tickaligned" makes limits align with the closest ticks.  With value "tight" the limits are adjusted to enclose all the graphics objects in the axes, while with value "padded", an additional margin of about 7% of the data extent is added around the objects.  See axis function.

ylimmode: {"auto"} | "manual"
     Current state of the y-axis limit selection method, either manually set with the "ylim" property or automatically set to span the plotted data according to the "ylimitmethod" property.

ytick: vector
     Position of y tick marks.  Setting ytick also forces the ytickmode property to be set to "manual".

ytickmode: {"auto"} | "manual"
     Setting to determine whether the ytick locations and spacing are set automatically by Octave or manually using the "ytick" property.

zaxis (read-only): def. [](0x0)
     Axes Ruler objects is not yet implemented for axes objects.  zaxis is unused.

zcolor: {colorspec} | "none", def. [0.1500   0.1500   0.1500]
     Color of the z-axis.  See colorspec.

zcolormode: {"auto"} | "manual"
     Current state of the setting determining the color that is applied to the z-axis grid lines.  If set to "auto" and/or the "gridcolormode" property is set to "manual", the z-axis grid color will be defined by the "gridcolor" property.  Otherwise the z-axis grid color will be defined by the "zcolor" property.

zdir: {"normal"} | "reverse"
     Direction of the y-axis: "normal" is bottom to top in default 3-D views.

zlim: two-element vector, def. [0   1]
     Two-element vector [zmin zmax] specifying the limits for the z-axis.  Setting zlim also forces the zlimmode property to be set to "manual".  See zlim function.

zlimitmethod: "padded" | {"tickaligned"} | "tight"
     Method used to determine the z-axis limits when the xlimmode property is "auto".  The default value, "tickaligned" makes limits align with the closest ticks.  With value "tight" the limits are adjusted to enclose all the graphics objects in the axes, while with value "padded", an additional margin of about 7% of the data extent is added around the objects.  See axis function.

zlimmode: {"auto"} | "manual"
     Current state of the z-axis limit selection method, either manually set with the "zlim" property or automatically set to span the plotted data according to the "zlimitmethod" property.

zminortick: {"off"} | "on"
     Control whether minor z tick marks are displayed.

ztick: vector
     Position of z tick marks.  Setting ztick also forces the ztickmode property to be set to "manual".

ztickmode: {"auto"} | "manual"
     Setting to determine whether the ztick locations and spacing are set automatically by Octave or manually using the "ztick" property.

Axes Grid Appearance
....................

gridalpha: def. 0.1500
     Transparency is not yet implemented for axes objects.  gridalpha is unused.

gridalphamode: {"auto"} | "manual"
     Transparency is not yet implemented for axes objects.  gridalphamode is unused.

gridcolor: {colorspec} | "none", def. [0.1500   0.1500   0.1500]
     Color of the major grid lines.  See colorspec.  Setting gridcolor also forces the gridcolormode property to be set to "manual".

gridcolormode: {"auto"} | "manual"
     Current state of the gridcolor mode, either manually set by the "gridcolor" property or automatically set by Octave to the default value.

gridlinestyle: {"-"} | "--" | "-." | ":" | "none"
     See Line Styles.

innerposition: four-element vector, def. [0.1300   0.1100   0.7750   0.8150]
     The "innerposition" property is the same as the "position" property.

minorgridalpha: def. 0.2500
     Transparency is not yet implemented for axes objects.  minorgridalpha is unused.

minorgridalphamode: {"auto"} | "manual"
     Transparency is not yet implemented for axes objects.  minorgridalphamode is unused.

minorgridcolor: {colorspec} | "none", def. [0.1000   0.1000   0.1000]
     Color of the minor grid lines.  See colorspec.  Setting minorgridcolor also forces the minorgridcolormode property to be set to "manual".

minorgridcolormode: {"auto"} | "manual"
     Current state of the minorgridcolor mode, either manually set by the "minorgridcolor" property or automatically set by Octave to the default value.

minorgridlinestyle: "-" | "--" | "-." | {":"} | "none"
     See Line Styles.

xgrid: {"off"} | "on"
     Control whether major x grid lines are displayed.

xminorgrid: {"off"} | "on"
     Control whether minor x grid lines are displayed.

xscale: {"linear"} | "log"
     Set the x-axis to a linear or logarithmic scale.

ygrid: {"off"} | "on"
     Control whether major y grid lines are displayed.

yminorgrid: {"off"} | "on"
     Control whether minor y grid lines are displayed.

yminortick: {"off"} | "on"
     Control whether minor y tick marks are displayed.

yscale: {"linear"} | "log"
     Set the y-axis to a linear or logarithmic scale.

zgrid: {"off"} | "on"
     Control whether major z grid lines are displayed.

zminorgrid: {"off"} | "on"
     Control whether minor z grid lines are displayed.

zscale: {"linear"} | "log"
     Set the z-axis to a linear or logarithmic scale.

Callback Execution
..................

busyaction: "cancel" | {"queue"}
     Define how Octave handles the execution of this object's callback properties when it is unable to interrupt another object's executing callback.  This is only relevant when the currently executing callback object has its interruptible property set to "off".  The busyaction property of the interrupting callback object indicates whether the interrupting callback is queued ("queue" (default)) or discarded ("cancel"). See Callbacks section.

interactions (read-only): def. [](0x0)
     Interaction objects is not yet implemented for axes objects.  interactions is unused.

interruptible: "off" | {"on"}
     Specify whether this object's callback functions may be interrupted by other callbacks.  By default interruptible is "on" and callbacks that make use of drawnow, figure, waitfor, getframe or pause functions are eventually interrupted. See Callbacks section.

Camera and View Controls
........................

cameraposition: three-element vector, def. [0.5000   0.5000   9.1603]
     Coordinates of the camera position viewing the axes.  Setting cameraposition also forces the camerapositionmode property to be set to "manual".

camerapositionmode: {"auto"} | "manual"
     Current state of the camera position property, whether automatically set according to the view function, or manually set with the "cameraposition" property.

cameratarget: three-element vector, def. [0.5000   0.5000   0.5000]
     Coordinates of the point at which the viewing camera is aimed.  Setting cameratarget also forces the cameratargetmode property to be set to "manual".

cameratargetmode: {"auto"} | "manual"
     Current state of camera target property, either manually set with the "cameratarget" property or automatically positioned at the center of the axes plot area.

cameraupvector: three-element vector, def. [0   1   0]
     A 3-element vector defining the upward direction of the current view.  Note that the default is [0 1 0] for 2-D plots and [0 0 1] for 3-D plots.  Setting cameraupvector also forces the cameraupvectormode property to be set to "manual".

cameraupvectormode: {"auto"} | "manual"
     Current state of camera up vector property, set to manual when the "cameraupvector" property is used to change the vector from the 2-D or 3-D default values.

cameraviewangle: scalar, def. 6.6086
     The camera's field of view defined as an angle between 0 and 180 degrees.  Setting cameraviewangle also forces the cameraviewanglemode property to be set to "manual".

cameraviewanglemode: {"auto"} | "manual"
     Current state of the camera view angle property, either manually set with the "cameraviewangle" property or automatically set by Octave to include all visible objects.

projection: {"orthographic"} | "perspective"
     Orthographic/perspective projection adjustment is not yet implemented for axes objects.  projection is unused.

view: two-element vector, def. [0   90]
     Two-element vector [azimuth elevation] specifying the viewpoint for three-dimensional plots.

Color and Transparency
......................

alim: def. [0   1]
     Transparency is not yet implemented for axes objects.  alim is unused.

alimmode: {"auto"} | "manual"
     Transparency is not yet implemented for axes objects.  alimmode is unused.

alphamap: def. [](0x0)
     Transparency is not yet implemented for axes objects.  alphamap is unused.

alphascale: {"linear"} | "log"
     Transparency is not yet implemented for axes objects.  alphascale is unused.

ambientlightcolor: def. [1   1   1]
     Uniform background axes lighting is not yet implemented for axes objects.  ambientlightcolor is unused.

clim: two-element vector, def. [0   1]
     Define limits for the color axis of axes children that have the cdata property.  Setting clim also forces the climmode property to be set to "manual".

climmode: {"auto"} | "manual"
     Current state of the color limit mode, either manually set by the "clim" property or automatically set by Octave to the minimum and maximum cdata values of axes's children.

colormap: N-by-3 matrix, def. 64-by-3 double
     A matrix containing the RGB color map for this axes object.

colorscale: {"linear"} | "log"
     Automatic linear/log color scaling is not yet implemented for axes objects.  colorscale is unused.

Creation/Deletion
.................

beingdeleted: {"off"} | "on"
     Property indicating that a function has initiated deletion of the object.  beingdeleted is set to true until the object no longer exists.

createfcn: string | function handle, def. [](0x0)
     Callback function executed immediately after axes has been created.  Function is set by using default property on root object, e.g., set (groot, "defaultaxescreatefcn", 'disp ("axes created!")').

     For information on how to write graphics listener functions see Callbacks section.

deletefcn: string | function handle, def. [](0x0)
     Callback function executed immediately before axes is deleted.

     For information on how to write graphics listener functions see Callbacks section.

Display
.......

clipping: "off" | {"on"}
     Axes-children clipping control is not yet implemented for axes objects.  clipping is unused.

clippingstyle: {"3dbox"} | "rectangle"
     Axes-children clipping control is not yet implemented for axes objects.  clippingstyle is unused.

visible: "off" | {"on"}
     If visible is "off", the axes is not rendered on screen.

Mouse Interaction
.................

buttondownfcn: string | function handle, def. [](0x0)
     For information on how to write graphics listener functions see Callbacks section.

contextmenu: graphics handle, def. [](0x0)
     Graphics handle of the uicontextmenu object that is currently associated to this axes object.

currentpoint: 2-by-3 matrix, def. 2-by-3 double
     Matrix [xf, yf, zf; xb, yb, zb] which holds the coordinates (in axes data units) of the point over which the mouse pointer was when the mouse button was pressed.  If a mouse callback function is defined, currentpoint holds the pointer coordinates at the time the mouse button was pressed.  For 3-D plots, the first row of the returned matrix specifies the point nearest to the current camera position and the second row the furthest point.  The two points forms a line which is perpendicular to the screen.

hittest: "off" | {"on"}
     Specify whether axes processes mouse events or passes them to ancestors of the object.  When enabled, the object may respond to mouse clicks by evaluating the "buttondownfcn", showing the uicontextmenu, and eventually becoming the root "currentobject".  This property is only relevant when the object can accept mouse clicks which is determined by the "pickableparts" property.  See pickableparts property.

mousewheelzoom: scalar in the range (0, 1), def. 0.5000
     Fraction of axes limits to zoom for each wheel movement.

pickableparts: "all" | "none" | {"visible"}
     Specify whether axes will accept mouse clicks.  By default, pickableparts is "visible" and only visible parts of the axes or its children may react to mouse clicks.  When pickableparts is "all" both visible and invisible parts (or children) may react to mouse clicks.  When pickableparts is "none" mouse clicks on the object are ignored and transmitted to any objects underneath this one.  When an object is configured to accept mouse clicks the "hittest" property will determine how they are processed.  See hittest property.

selected: {"off"} | "on"
     Property indicates whether this axes is selected.

selectionhighlight: "off" | {"on"}
     If selectionhighlight is "on", then the axes's selection state is visually highlighted.

Object Identification
.....................

nextplot: "add" | {"replace"} | "replacechildren"
     nextplot is used by high level plotting functions to decide what to do with graphics objects already present in the axes.  See newplot function.  The state of nextplot is typically controlled using the hold function.  See hold function.

tag: string, def. ""
     A user-defined string to label the graphics object.

title: graphics handle
     Graphics handle of the title text object.

type (read-only): string
     Class name of the graphics object.  type is always "axes".

userdata: Any Octave data, def. [](0x0)
     User-defined data to associate with the graphics object.

Object Position
...............

outerposition: four-element vector, def. [0   0   1   1]
     Specify the position of the plot including titles, axes, and legend.  The four elements of the vector are the coordinates of the lower left corner and width and height of the plot, in units normalized to the width and height of the plot window.  For example, [0.2, 0.3, 0.4, 0.5] sets the lower left corner of the axes at (0.2, 0.3) and the width and height to be 0.4 and 0.5 respectively.  See position property.

plotboxaspectratio: def. [1   1   1]
     See pbaspect function.  Setting plotboxaspectratio also forces the plotboxaspectratiomode property to be set to "manual".

plotboxaspectratiomode: {"auto"} | "manual"
     Current state of the plot box aspect ratio mode, either manually set by the "dataaspectratio" property or automatically set by Octave in combination with other display properties to fit the data in the current view.

position: four-element vector, def. [0.1300   0.1100   0.7750   0.8150]
     Specify the position of the plot excluding titles, axes, and legend.  The four elements of the vector are the coordinates of the lower left corner and width and height of the plot, in units normalized to the width and height of the plot window.  For example, [0.2, 0.3, 0.4, 0.5] sets the lower left corner of the axes at (0.2, 0.3) and the width and height to be 0.4 and 0.5 respectively.  See outerposition property.

positionconstraint: "innerposition" | {"outerposition"}
     Specify which of "innerposition" or "outerposition" properties takes precedence when axes annotations extent changes.  See "innerposition" property, and "outerposition" property.

units: "centimeters" | "characters" | "inches" | {"normalized"} | "pixels" | "points"
     Units used to interpret the "position", "outerposition", and "tightinset" properties.

Parent/Children
...............

children (read-only): vector of graphics handles, def. [](0x1)
     Graphics handles of the axes's children.

handlevisibility: "callback" | "off" | {"on"}
     If handlevisibility is "off", the axes's handle is not visible in its parent's "children" property.

parent: graphics handle
     Handle of the parent graphics object.

sortmethod: "childorder" | {"depth"}
     Child display order control is not yet implemented for axes objects.  sortmethod is unused.

Text Appearance
...............

fontangle: "italic" | {"normal"}
     Control whether the font is italic or normal.

fontname: string, def. "*"
     Name of font used for text rendering.  When setting this property, the text rendering engine will search for a matching font in your system.  If none is found then text is rendered using a default sans serif font (same as the default "*" value).

     Programming Note: On systems that don’t use FontConfig natively (all but Linux), the font cache is built when Octave is installed.  You will need to run system ("fc-cache -fv") manually after installing new fonts.

fontsize: scalar, def. 10
     Size of the font used for text rendering.  See fontunits property.  Setting fontsize also forces the fontsizemode property to be set to "manual".

fontsizemode: {"auto"} | "manual"
     Current state of the fontsize mode, either manually set by the "fontsize" property or automatically set by Octave to maintain readability.

fontsmoothing: "off" | {"on"}
     Control whether any text associated with axes is anti-aliased.

fontunits: "centimeters" | "inches" | "normalized" | "pixels" | {"points"}
     Units used to interpret the "fontsize" property.

fontweight: "bold" | {"normal"}
     Control the variant of the base font used for text rendering.

labelfontsizemultiplier: def. 1.1000
     Ratio between the x/y/zlabel fontsize and the tick label fontsize.

legend (read-only): def. [](0x0)
     Legend property control is not yet implemented for axes objects.  legend is unused.  Use the legend function to set legend properties.

ticklabelinterpreter: "latex" | "none" | {"tex"}
     Control the way x/y/zticklabel properties are interpreted. See Use of the "interpreter" Property.

tightinset (read-only): four-element vector
     Size of the [left bottom right top] margins around the axes that enclose labels and title annotations.

titlefontsizemultiplier: positive scalar, def. 1.1000
     Ratio between the title fontsize and the tick label fontsize.

titlefontweight: {"bold"} | "normal"
     Control variant of base font used for the axes title.

xlabel: graphics handle
     Graphics handle of the x label text object.

xticklabel: string | cell array of strings, def. 6-by-1 cell
     Labels of x tick marks.  Setting xticklabel also forces the xticklabelmode property to be set to "manual".

xticklabelmode: {"auto"} | "manual"
     Setting to determine whether the xtick labels are set automatically by Octave or manually using the "xticklabel" property.

xticklabelrotation: def. 0
     Axis label rotation is not yet implemented for axes objects.  xticklabelrotation is unused.

ylabel: graphics handle
     Graphics handle of the y label text object.

yticklabel: string | cell array of strings, def. 6-by-1 cell
     Labels of y tick marks.  Setting yticklabel also forces the yticklabelmode property to be set to "manual".

yticklabelmode: {"auto"} | "manual"
     Setting to determine whether the ytick labels are set automatically by Octave or manually using the "yticklabel" property.

yticklabelrotation: def. 0
     Axis label rotation is not yet implemented for axes objects.  yticklabelrotation is unused.

zlabel: graphics handle
     Graphics handle of the z label text object.

zticklabel: string | cell array of strings, def. 6-by-1 cell
     Labels of z tick marks.  Setting zticklabel also forces the zticklabelmode property to be set to "manual".

zticklabelmode: {"auto"} | "manual"
     Setting to determine whether the ztick labels are set automatically by Octave or manually using the "zticklabel" property.

zticklabelrotation: def. 0
     Axis label rotation is not yet implemented for axes objects.  zticklabelrotation is unused.