42
The following solution is hacky work-around to overcome the lack of proper pattern directives. I don't like it 100%, but still it is usable.
Solution
The idea is simple. If you see FilledCurve documentation, it supports an object with holes:
So what if you put a huge enough rectangle as an outer boundary? Then, your polygon becomes a hole and you can see ...
29
How about this?
bankerPlot[data_] := ListLinePlot[
data,
AxesOrigin -> {0, 0},
Prolog -> Polygon[Join[data, Reverse[data.DiagonalMatrix[{1, 0}]]],
VertexColors -> Join[
Blend[{Black, Blue}, #] & /@ Normalize[data[[All, 2]], Max],
ConstantArray[Black, Length[data]]
]
],
PlotStyle -> White,
Background -> ...
28
An alternative is to use Piecewise as follows
Plot[{Sin[x], Piecewise[{{Sin[x], -Pi <= x <= Pi}}, _]}, {x, -2 Pi, 2 Pi},
Filling -> {2 -> {Axis, Yellow}}, PlotStyle -> {Green, Directive[Red, Thick]}]
which gives
Or
Use Show to superimpose two variants (the second one with your choice of the variable bounds -- -Pi and 2Pi in the ...
27
You have a (or more) curves. If you don't use PolarPlot you could use ParametricPlot instead but you would have to make the transformation from polar coordinates by yourself.
Knowing this, you could think about what your functions mean. For instance 2 (1 - Cos[phi]) is just the radius of your curve for a given phi. If you want to draw the region outside ...
25
ragfield's solution is a good one that can easily be extended to arbitrarily complicated polygons if we create an inPolyQ function using winding numbers.
Here is a complicated polygon (the points only) from Mathematica's example data.
poly = Rescale[ExampleData[{"Statistics", "WesternUgandaBorder"}]];
This function determines whether a point is in the ...
25
This is a simple little hack that will replace the polygons created by your Filling command with a set of random points. By default I'm scaling the number of random points by the number of points in the polygon, so that the density of points stays relatively constant.
dotFillPlot[plot_, ndots_: 5] :=
plot // Normal //
ReplaceAll[
Polygon[a__] :> ...
23
Update 2: Finally ... in version 12.1 you can use the new directives HatchFilling and PatternFilling:
Graphics[{EdgeForm[{Thick, Black}], #, blob}, ImageSize -> 300] & /@
{HatchFilling[], Directive[Red, HatchFilling[Pi/2, 2, 10]]} // Row
Graphics[{EdgeForm[{Thick, Black}], PatternFilling[#, ImageScaled[1/20]], blob},
ImageSize -> 300] &...
22
Even if Filling were an option in PolarPlot, you won't be able to create such a plot because for 2D graphics, Filling just blindly fills along the y-axis, whereas you need to check for an inequality here.
That said, here's another approach that's in the same spirit as halirutan's, but you don't have to convert to Cartesian, etc.
eqns[t_] := { Sqrt[2 Cos[t]...
22
For plotting a continuous function, you could do something like this:
f[x_] := (1 + Cos[5 x]/2) Sin[x]
ParametricPlot[{x, f[x] y}, {x, 0, Pi}, {y, 0, 1},
PlotPoints -> 30,
ColorFunction -> (Blend[{Black, Blue, White}, #2] &), Mesh -> None,
AspectRatio -> 1/GoldenRatio]
Edit
This method can be used for plotting a list of points as ...
22
I was sure Histogram can be modified to have the hatching style. Little late but what about this!
g[{{xmin_, xmax_}, {ymin_, ymax_}}, ___] := Module[{yval, line},
yval = Range[ymin, ymax, 15];
line = Line /@ Transpose@{Most@({xmin, #} & /@ yval),Rest@({xmax, #} & /@ yval)};
{FaceForm[White],Polygon[{{xmin, ymin}, {xmax, ymin}, {xmax, ymax}, {...
19
Something like this?
RegionPlot[y < 1/x && y + 0.3 > 1/(x + 0.3) , {x, 0, 3}, {y, 0, 4},
AxesOrigin -> {0, 0}, Frame -> False, Axes -> Automatic, Mesh -> 20,
MeshFunctions -> {#1 - #2 &}, BoundaryStyle -> None]~Show~
Plot[1/x, {x, 0, 3}]
You can add PlotStyle -> Transparent to the RegionPlot if you don't ...
18
Here's a modification of Heike's ParametricPlot approach, using textures instead of ColorFunction.
pts1 = RandomReal[10, 100];
interpol = Interpolation[pts1, InterpolationOrder -> 1];
ParametricPlot[{u, interpol[u] v}, {u, 1, Length[pts1]}, {v, 0, 1},
Mesh -> None, AspectRatio -> 1/GoldenRatio,
TextureCoordinateFunction -> ({#1, #2} &),...
18
Plot[{0.8333*H + 16.928*H^0.25 - 85, Max[-9 + Max[H - 80, 0], H - 80]}, {H, 0, 700},
PlotStyle -> {Directive[Black, Thick], Black},
Filling -> {1 -> {{2}, {Yellow, Transparent}}}]
17
Just another way:
<< VectorAnalysis`;
{rho, t, z} = CoordinatesFromCartesian[{x, y, z}, Cylindrical]
Quiet@Show[
PolarPlot[{ Sqrt[2 Cos@t], 2 (1 - Cos@t)}, {t, -Pi, Pi}],
RegionPlot[ Sqrt[2 Cos@t] > rho > 2 (1 - Cos@t), {x, 0, 2}, {y, -1, 1}]]
17
Mathematica's graphics language lacks a clipping primitive. However, you can sometimes simulate the same appearance using the sophisticated visualization functions.
RegionPlot[((0 <= x <= .5) && (0 <= y <= 1 + x)) || ((.5 < x <= 1) &&
0 <= y <= 2 - x), {x, -1, 2}, {y, -1, 2}, Mesh -> 20,
MeshFunctions -> ...
17
You can post-process ParametricPlot output to change Line to FilledCurve:
ParametricPlot[{(1 - Cos[2 π s]) Sin[2 π s],
Cos[2 π s] (Sin[2 π s] + 1)}, {s, 0, 1}, Axes -> False,
PlotStyle -> Black] /. l_Line :> FilledCurve[l]
Use the replacement rule
l_Line :> {Opacity[1.], FilledCurve[l]}
to get
We get the same result if we use a rule ...
16
This is a variant of Argento's answer with the blend on a rectangle in the background rather than creating a polygon that matches the data.
bankerData =
Transpose[{Range[100], Accumulate[RandomReal[{-1, 1}, 100]] + 10}];
ListLinePlot[bankerData, Frame -> True, Background -> Black,
AxesOrigin -> {0, 0}, PlotRange -> {{1, 100}, {0, 20}},
...
16
Yet another way. It's similar to belisarius's solutions but doesn't require an inverse coordinate transformation
Show[
PolarPlot[{Sqrt[2 Abs[Cos[t]]], 2 (1 - Cos[t])}, {t, -\[Pi], \[Pi]}],
RegionPlot[4 (1 - Cos[t])^2 < r^2 < 2 Cos[t], {r, 0, 3}, {t, -Pi, Pi},
PlotPoints -> 30] /.
GraphicsComplex[a_, b__] :> GraphicsComplex[#1 {Cos[#2], ...
16
I would do something like:
t = RandomVariate[NormalDistribution[0, 1], 10000];
a = Histogram[t, 30, ChartStyle -> White];
b = Histogram[t, 30,
ChartElements -> Graphics[{Black, Line[{{0, 0}, {1, 1}}]}]];
Show[a, b]
15
You can parameterize your polar functions on to discs, and then shade appropriately.
ρ[t_] := Sqrt[2 Cos[t]];
σ[t_] := 2 (1 - Cos[t]);
ParametricPlot[{{r Cos[t] ρ[t], r Sin[t] ρ[t]}, {r Cos[t] σ[t], r Sin[t] σ[t]}},
{t, -π, π}, {r, 0, 1}, PlotStyle -> {{Opacity[.5], Red}, {Opacity[1], White}},
Mesh -> None, PlotRange -> All]
15
I have distilled a minimal dataset reproducing the problem:
data = {{{45.904`, 227.46`}, {46.012`, 222.72`}, {46.076`, 215.51`}, {46.107`,
206.26`}, {46.119`, 196.15`}, {46.119`, 186.97`}, {46.118`, 178.5`}, {46.104`,
168.16`}, {46.079`, 156.43`}}, {{45.912`, 212.72`}, {45.976`, 205.51`}, {46.007`,
196.26`}, {46.019`, 186.15`}, {46.019`, ...
14
The FilledCurve approach in the accepted answer by @Yu-Sung Chang is very interesting, so I tried to make my own version of it. I defined the whole thing as a function that accepts graphics directives for the objects to be masked (backgroundDirectives - e.g., the fill pattern or image), and an arbitrary polygon as the mask. This includes Polygon with several ...
14
How about
dt = Pi/99;
pts = Join[
Table[2 (1 - Cos[t]) {Cos[t], Sin[t]},
{t, 0, -Pi/3 + dt, -dt}],
Table[Sqrt[2 Cos[t]] {Cos[t], Sin[t]},
{t, -Pi/3, Pi/3, dt}],
Table[2 (1 - Cos[t]) {Cos[t], Sin[t]},
{t, Pi/3, dt, -dt}]
];
PolarPlot[{Sqrt[2 Cos[t]], 2 (1 - Cos[t])}, {t, -\[Pi], \[Pi]},
Prolog -> {LightGray, Polygon[pts]},
...
14
Here's a meager attempt that will soon be humiliated by Heike's answer. ;-)
g = PolarPlot[Evaluate@{{1, -1} Sqrt[2 Cos[t]],
2 (1 - Cos[t])}, {t, -\[Pi], \[Pi]}];
Graphics[{
{Pink, Rectangle[Scaled[{0, 0}], Scaled[{1, 1}]]},
Thread@{{White, Green, Blue},
Reverse@Cases[g, Line[x__] :> Polygon[x], ∞]}
}];
Show[g, %, g]
Seeing as I ...
14
Here's happy:
Plot[{Sin[9 \[Pi] t/10], 2 Sin[7 \[Pi] t/10]}, {t, 0, 20},
AspectRatio -> 0.2, AxesLabel -> {"weeks", "affection"},
Filling -> {1 -> {Axis, {None, Green}}, 1 -> {{2}, White}}]
14
Here is extended version of PlatoManiac's solution which allows changing of the direction of the hatching and also tuning the distance between hatches:
g[step_?NumberQ][{{xmin_, xmax_}, {ymin_, ymax_}}, ___] :=
Module[{yval, lines, xstart, xend},
yval = Range[ymin, ymax, Abs[step]];
If[step > 0, {xstart, xend} = {xmin, xmax}, {xstart, xend} = {...
13
Alternatively, you can use the +/- option of Filling
Plot[{x + 7, 9 - x^2}, {x, 0, 1.5}, Filling -> {1 -> {{2}, {LightBlue, White}}}]
13
im = Binarize@Import["http://i.stack.imgur.com/ZDeYq.jpg"];
Colorize[MorphologicalComponents@im,
ColorRules -> {1 -> Red, 2 -> Yellow, 3 -> Blue, 4 -> Green}]
13
Changing the order of lists restore the filling
x = {{10.5, 8.5}, {20, 15.3, 11.9, 8.8}, {16.5, 12.5, 9.2, 6.5}};
ListLogPlot[x, Joined -> True, PlotRange -> {{1, 5}, All},
Filling -> {1 -> {{3}, Brown}, 2 -> {{3}, Gray}}]
13
It can be done in several ways, but, I am afraid, none of them with ease similar to setting the colors with an RGBColor command:)
1. Using Show and ParametricPlot with different Mesh* settings
Create four different ParametricPlot each with different settings for the Mesh* options and use Show to put them together:
ClearAll[meshedParametricPlot]
...
Only top voted, non community-wiki answers of a minimum length are eligible
