Graph[] has a tendency to cut off vertex labels in Mathematica. I am looking for a robust workaround.
Example:
Graph[{1 -> 2, 2 -> 3, 3 -> 1}, VertexLabels -> "Name"]
My present workaround:
SetOptions[Graph, ImagePadding -> 12]
This is not robust because the value of ImagePadding needs to be manually adjusted depending on the label size.
Apparently using FullGraphics on the Graph object will fix the clipping for the purpose of display, at the expense of interactivity.
Per the comment below, Show[] works as well, and avoids modifying the graphics.
Here are two possible workarounds.
Enlarge the vertex size and place the labels within the vertex. Of course, this also depends on the length of the labels, but for shortish labels it works well, whereas your example above clips off any label of more than one character for vertex 1.
ex:
Table[Graph[{1 -> 2, 2 -> 3, 3 -> 1}, VertexSize -> 0.3,
VertexLabels -> Table[i ->
Placed["vertex" <> ToString[i], p], {i, 3}],
VertexShapeFunction -> "Square", PlotLabel -> p],
{p, {Left, Top, Right, Bottom, Center}}]
Use tooltips to store the labels instead of displaying them on the graphic. [Edit: Center probably looks the best, and then you can wrap labels by putting \n in your string if you need to, but again, depends on the label length.]
ex:
Graph[{1 -> 2, 2 -> 3, 3 -> 1}, VertexLabels -> Placed["Name", Tooltip]]
While this stops you from being able to see all the labels at the same time, you never have any clipping.
Related
I can get a colored ListLinePlot by doing something like
ListLinePlot[Range[420, 680, 20], ColorFunction -> "VisibleSpectrum", ColorFunctionScaling -> False]
However, as indicated by the help file ("ColorFunction requires at least one dataset to be Joined"), if I do the equivalent
ListPlot[Range[420, 680, 20], ColorFunction -> "VisibleSpectrum", ColorFunctionScaling -> False]
all my points are blue. Is there a nice way to get ColorFunction to work for ListPlot with Joined -> False?
That is, is there a nicer way to get something like
ListPlot[
List /# Transpose[{Range[(680 - 420)/20 + 1], Range[420, 680, 20]}],
PlotMarkers -> ({Graphics[{#, Disk[]}], 0.05} & /# ColorData["VisibleSpectrum"] /# Range[420, 680, 20])
]
?
(Also, does anyone have an explanation of why Mathematica requires Joined -> True in order to make use of ColorFunction?)
Edit: I'm also looking for a way to do a similar coloring with ErrorListPlot in the ErrorBarPlots package.
The problem is, that Joined->True draws a Line[] which can be given VertexColors for each containing point. I assume doing the same for the points when setting Joined->False leads to situations where it does not work. Nevertheless, Line[] and Point[] work pretty much the same in your case. So what is about
ListLinePlot[Range[420, 680, 20], ColorFunction -> "VisibleSpectrum",
ColorFunctionScaling -> False] /. Line[arg___] :> Point[arg]
And, by the way, if your using a ListLinePlot only, where the only Line[] directives arising are the one from your data, this should work even if you have more datasets and {x,y} coordinates
data = Transpose[Table[{{x, Sin[x]}, {x, Cos[x]}}, {x, 0, 2 Pi, 0.2}]];
ListLinePlot[data, ColorFunction -> Hue] /. Line[arg___] :> Point[arg]
You can use DiscretePlot:
data = Range[420, 680, 20];
DiscretePlot[data[[i]], {i, Length[data]},
ColorFunction -> "VisibleSpectrum", ColorFunctionScaling -> False,
Filling -> None]
If you're plotting a list of x,y points, it gets a little trickier:
data = Transpose[{Range[420, 680, 20], Range[400, 530, 10]}];
mapping = Apply[Rule, data, 2];
DiscretePlot[i/.mapping, {i, data[[;;,1]]},
ColorFunction -> "VisibleSpectrum", ColorFunctionScaling -> False,
Filling -> None]
It does seem rather odd that DiscretePlot will let you color the points differently whereas ListPlot won't. I'm sure it must have something to do with the implementation details, but I can't think of a reason why that would be the case.
I came across this problem in my work too. I assign a colour to each point in the following manner:
data = ...
ListPlot[data] /. Point[args___] :> Point[args, VertexColors -> {c1, c2, ...}]
where c1 is the colour for the first data point, and so on. The colour list may be programmatically generated, eg
ColorData["Rainbow"] /# (Range#Length#data / Length#data)
Here is the result.
The good points of this method are as follows.
It's straightforward: we have a list of pairs, then we create a corresponding list of colours.
Our original ListPlot code needs not be modified (eg, changed into ListLinePlot).
How can I label each of these lines separately :
Plot[{{5 + 2 x}, {6 + x}}, {x, 0, 10}]
There's some nice code that allows you to do this dynamically in an answer to How to annotate multiple datasets in ListPlots.
There's also a LabelPlot command defined in the Technical Note Labeling Curves in Plots
Of course, if you don't have too many images to make,
then it's not hard to manually add the labels in using Epilog, for example
fns[x_] := {5 + 2 x, 6 + x};
len := Length[fns[x]];
Plot[Evaluate[fns[x]], {x, 0, 10},
Epilog -> Table[Inset[
Framed[DisplayForm[fns[x][[i]]], RoundingRadius -> 5],
{5, fns[5][[i]]}, Background -> White], {i, len}]]
In fact, you can do something similar with Locators that allows you to move the labels wherever you want:
DynamicModule[{pos = Table[{1, fns[1][[i]]}, {i, len}]},
LocatorPane[Dynamic[pos], Plot[Evaluate[fns[x]], {x, 0, 10}],
Appearance -> Table[Framed[Text#TraditionalForm[fns[x][[i]]],
RoundingRadius -> 5, Background -> White], {i, len}]]]
In the above I made the locators take the form of the labels, although it is also possible to keep an Epilog like that above and have invisible locators that control the positions.
The locators could also be constrained (using the 2nd argument of Dynamic) to the appropriate curves... but that's not really necessary.
As an example of the above code with the functions with the labels moved by hand:
fns[x_] := {Log[x], Exp[x], Sin[x], Cos[x]};
Mathematica 9 now provides easy ways to include legends.
Plot[{{5 + 2 x}, {6 + x}}, {x, 0, 10}, PlotLegends -> "Expressions"]
You can insert legends in your plot by loading the PlotLegends package
<<PlotLegends`;
Plot[{5+2 x,6+x},{x,0,10},
PlotLegend->{"5+2x","6+x"},LegendShadow->None,
LegendPosition->{0.3,-0.5},LegendSpacing->-0,LegendSize->0.5]
However, let me also note my dislike of this package, primarily because it's extremely counterintuitive, laden with too many options and does not provide a clean experience right out of the box like most of Mathematica's functions. You will have some fiddling around to do with the options to get what you want. However, in plots and charts where you do want a legend, this can be handy. Also see the comments to this answer and this question.
Is there any reason that underlies mathematica's way of presenting this graph
ListPlot[
Table[{x, x*01}, {x, -5, 5, .08}],
PlotStyle -> White,
Filling -> 0,
FillingStyle -> {Dashed, Brown}]
While the dashing is present for the part of the graph above the zero boundary, another part of the graph has the filling that is solid.
Am I doing something wrong?
Not that wrong. Mathematica is interpreting your filling style as being Dashed below zero and Brown above. You just need another pair of braces, like so:
ListPlot[Table[{x, x*01}, {x, -5, 5, .08}], PlotStyle -> White,
Filling -> 0, FillingStyle -> {{Dashed, Brown}}]
Hope that helps.
I apologise for the length of this question. My current Mathematica programming project involves replicating the very specific business rules my employing institution has for publication-quality plots of time series. One of these rules is that multipanel graphs have panel titles and subtitles centered near the top of the plot area. This worked fine using Prolog and Inset until I redid that bit of the function to allow explicit Prolog elements to be included as well. Then only the item passed in the Prolog option shows, not the panel titles and subtitles. If there is no explicit Prolog option, the panel titles and subtitles show up fine.
To explicate a bit further, imagine the function body is all in a big Module, including the local variable pl=OptionValue[Prolog] and mp=OptionValue[MultiPanel].
A bit further down is this definition (ppl, title and subtitle were also defined as local variables, and Rfont and framecol are constants defined elsewhere in the package, namely to be "Arial" and "Black"):
ppl=If[mp===False,pl,If[Length[pl]>0,Join[{
If[ToString[subtitle] == "None", Inset[
DisplayForm[GridBox[{{Style[title, 20, FontFamily -> Rfont, framecol]}}]],
Scaled[{0.5,0.96}],{Center,Top} ],
Inset[DisplayForm[
GridBox[{{Style[title, 20, FontFamily -> Rfont, framecol]},
{Style[subtitle, 16, FontFamily -> Rfont, framecol]}},
RowSpacings -> 0]],Scaled[{0.5,0.98}],{Center,Top}] ]},pl],
{If[ToString[subtitle] == "None",
Inset[ DisplayForm[
GridBox[{{Style[title, 20, FontFamily -> Rfont, framecol]}}]],
Scaled[{0.5,0.96}],{Center,Top} ],
Inset[DisplayForm[
GridBox[{{Style[title, 20, FontFamily -> Rfont, framecol]},
{Style[subtitle, 16, FontFamily -> Rfont, framecol]}},
RowSpacings -> 0]],Scaled[{0.5,0.98}],{Center,Top}]] }] ]
All fine as far as it goes. The Inset is used if the option MultiPanel (and thus mp) is not False and there is no Prolog explicitly set. But if a prolog is set, e.g., Prolog -> {Text["test", Scaled[{0.6, 0.5}]]}, then the Inset doesn't show, only the Text element.
It isn't a problem with the way I am joining them together. Capturing and printing the value of ppl gives:
{Inset[{{Style["This is a test", LineColor -> GrayLevel[0],
FrontFaceColor -> GrayLevel[0], BackFaceColor -> GrayLevel[0],
GraphicsColor -> GrayLevel[0], FontFamily -> "Arial", FontSize -> 20,
FontColor -> GrayLevel[0]]},
{Style["Year-ended percentage change", LineColor -> GrayLevel[0],
FrontFaceColor -> GrayLevel[0], BackFaceColor -> GrayLevel[0],
GraphicsColor -> GrayLevel[0], FontFamily -> "Arial", FontSize -> 16,
FontColor -> GrayLevel[0]]}},
Scaled[{0.5, 0.98}], {Center, Top}], Text["test", Scaled[{0.6, 0.5}]]}
(And yes, those are a bunch of undocumented options which I shall ask about in another question.)
Does anyone know if there is anything preventing Prolog (or Epilog for that matter) combining Inset elements and other things in the one set of graphics options?
As you have not given a working fragment of code, I'm not sure what's going wrong in it.
How does my simple example not replicate what you're trying?
plot = Plot[x^2, {x, -5, 5}, Prolog -> Inset[Style[Text[":) = \[HappySmiley]"], Large]]]
pl = Flatten#{Prolog /. AbsoluteOptions[plot, Prolog]}
join = Show[{Plot[x^2 + 1, {x, -5, 5}, PlotStyle -> Red],
Plot[x^2, {x, -5, 5}, PlotStyle -> Blue]},
Prolog -> Join[{Inset[Graphics#Circle[]]}, If[Length[pl] > 0, pl, {}]]]
I feel a bit stupid now. I worked out the issue. Let me see if I can explain clearly enough.
Suppose you have a custom function (say, XYZPlot) that is built on a built-in one (say, DateListPlot). Suppose you want to pass some options to DateListPlot, as well as handling some options that are specific to XYZPlot. Then you probably want to pass any options the user includes explicitly before you pass the default options that apply to your custom function. This is a toy example: normally you'd set default PlotRange as an option to your custom function with SetOptions etc.
defaultplotrange = {1,5};
XYZPlot[args___,opts:OptionsPattern[{XYZPlot,DateListPlot}]]:=
DateListPlot[args,Sequence ## FilterRules[{opts}, Options[DateListPlot]],
PlotRange->defaultplotrange]
So far so good. But if you want to catch the value of an option and modify it even if the user provides an explicit value for it when they call the function, for example to add [ahem] panel titles if some other option is set to True, then you can't put that option after the FilterRules bit. It has to come before. Otherwise the value of Prolog that the user gave will be used, not the one with the bit added. So the right way is to do something like this.
defaultplotrange = {1,5};
XYZPlot[args___,opts:OptionsPattern[{XYZPlot,DateListPlot}]]:=
With[{pl=OptionValue[Prolog],mp=OptionValue[MultiPanel]},
DateListPlot[args,
Prolog -> If[mp===False,pl,Join[pl,{Inset[(* something else *)]}]],
Sequence ## FilterRules[{opts}, Options[DateListPlot]],
PlotRange->defaultplotrange]]
Sorry to bother you all.
I would like to draw a rectangle (or more) which printed on paper shows the rectangle in units of cm.
So
Graphics[{Rectangle[{0, 0}, {19, 28}], Orange, Rectangle[{0, 0}, {1, 1}]}]
will print out as two rectangles which can be measured as exactly 1cm x 1cm (orange one) and the black one as 19x28 cm.
It seems that some variables are important:
The ImageSize and of course the AspectRatio.
I used AspectRatio->19/28 and for the ImageSize various settings like ImageSize->{19*27,28*27} but it keeps being not very accurate.
I export the graphics to TIFF and then print out with windows photo gallery to a full page photo. Does anyone have experience with this? There must be a formula instead of trial and error.
UPDATE:
I tried the suggestion of #Szabolcs and I used the following code:
g = Graphics[{White, EdgeForm[Directive[Thick, Black]],
Rectangle[{0, 0}, {18, 28}], Orange, Rectangle[{0, 0}, {10, 10}]}]
final = Show[g, AspectRatio -> Automatic,
PlotRange -> {{-0.5, 18.5}, {-0.5, 28.5}}]
cm = 72/2.54
Export["final.pdf", Show[final, ImageSize -> {19 cm, 29 cm}]]
This works great. The orange rectangle of 10x10cm is when measured exactly 10x10cm
the cm 72/2.54 value was not what I expected since I though Windows uses 96dpi and Mac 72dpi (reading from the www). However 72 is the value that works.
I've also beenn playing with the frames but then it gets ugly. Haven't found a way to get the right results dispite playing with all possible settings. What should work is create the frames/ticks etc myself inside the selected boundaries but that's not the path I would like to pursue..
g = Graphics[{Rectangle[{0, 0}, {19, 28}], Orange, Rectangle[{0, 0}, {1, 1}]}]
Okay, first thing you need to do is set the x and y directions to use the same units, which means
Show[g, AspectRatio -> Automatic]
But this is already the default.
Second thing you need to do is choose a size and range for your plot area. Let's make it 21 by 30 with your rectangles centred:
plotArea = {{0, 21}, {0, 30}} - {1, 1}
Show[g, AspectRatio -> Automatic, PlotRange -> plotArea]
Third thing you need to do is turning off adding any padding/margins that make the actual size of your figure larger than your plot range:
final = Show[g, AspectRatio -> Automatic, PlotRange -> plotArea, PlotRangePadding -> 0, ImagePadding -> 0]
I believe ImageMargins does not make a difference, but if it does, set that to 0 as well.
The final thing you need to do is export this to a printable format that preserves the image dimensions, and set the size of the image so that 1 cm will be 1 unit on your plot. Mathematica accepts image sizes in printer's points, so let's define:
cm = 72/2.54
Export["final.pdf", Show[final, ImageSize -> 21 cm]]
We want the plot to be 21 cm wide because it's 21 units wide. Use PDF as export format, not TIFF. The ImageSize needs to be used inside Show to work around some problems with Export ...
Now open your PDF in Adobe Reader, open the print dialogue, and make sure that Page Scaling is set to None! I don't know how to do this in other readers ... Also make sure your figure fits the paper (21 by 30 cm is too large for A4 ...)
I'm not going to do a test print, so let me know if this works for you :-) The size of the PDF generated this way is exactly 21 by 30 cm, so if something goes wrong, it must happen at the printing stage.
I believe you need to add PlotRangePadding -> None and set image dimensions appropriately.
In this case, the "bounding box" size is the same as your larger rectangle: {19, 28}
The robust way to do this is to set ImageSize to the actual required dimensions, and make use of ImageResolution, which will embed this value into the TIFF file for proper printing:
cm = 72 / 2.54;
g = Graphics[{Rectangle[{0, 0}, {19, 28}], Orange,
Rectangle[{0, 0}, {1, 1}]}, PlotRangePadding -> None,
ImageSize -> {19, 28}*cm];
Export["print.tif", g, ImageResolution -> 300]
This assumes that you want to print from a raster format (TIFF) but you can also export to other formats such as PDF with the same method.