PoissonPointProcess[μ,d]
represents a homogeneous Poisson point process with constant intensity μ in 
.
PoissonPointProcess
PoissonPointProcess[μ,d]
represents a homogeneous Poisson point process with constant intensity μ in 
.
Details
- PoissonPointProcess is also known as homogeneous Poisson point process, stationary Poisson point process and complete spatial randomness (CSR).
- PoissonPointProcess generates points that are uniformly distributed in a region, with the average number of points per unit volume equal to μ.
- Typical uses are to model and test point collections that are completely spatially random. They are frequently used as building blocks for more complicated point processes such as clustered point processes.
- With intensity μ, the number of points in the observation region with volume
follows the distribution PoissonDistribution[μ ν]. - The number of points
in disjoint regions 
for a Poisson point process consists of independent random variables so 
. This property is also referred to as complete spatial randomness (CSR). - A point configuration
with intensity μ in an observation region 
with volume 
has density function 
with respect to PoissonPointProcess[1,d]. - The Papangelou conditional density
for adding a point 
to a point configuration 
is 
for a Poisson point process with intensity μ. - PoissonPointProcess allows μ to be any positive real number and d to be any positive integer.
- Possible PointProcessEstimator settings in EstimatedPointProcess for PoissonPointProcess are:
-
Automatic automatically choose the parameter estimator "MaximumPseudoLikelihood" maximize the pseudo-likelihood - PoissonPointProcess can be used with such functions as RipleyK and RandomPointConfiguration.
Examples
open all close allBasic Examples (3)
Sample from a Poisson point process:
pts = RandomPointConfiguration[PoissonPointProcess[100, 2], Disk[]]Show[RegionPlot[pts["ObservationRegion"]], ListPlot[pts]]Sample a Poison point process with several realizations:
pts = RandomPointConfiguration[PoissonPointProcess[60, 2], Disk[], 3]pts["ConfigurationCount"]pts["PointCountList"]ListPlot[pts, AspectRatio -> 1]Simulate Poisson point process over a country:
proc = PoissonPointProcess[Quantity[.001, 1 / "Kilometers" ^ 2], 2];pts = RandomPointConfiguration[proc, Entity["Country", "France"]]GeoListPlot[pts]Scope (4)
Sample a Poisson point process from any valid region whose RegionEmbeddingDimension is equal to its RegionDimension:
ℛ = ImplicitRegion[x ^ 2 - 2y ^ 2 <= 1, {{x, -3, 3}, {y, -4, 4}}];{RegionQ[ℛ], RegionEmbeddingDimension[ℛ] == RegionDimension[ℛ]}Sample points from the region:
pts = RandomPointConfiguration[PoissonPointProcess[6, 2], ℛ]Show[RegionPlot[pts["ObservationRegion"]], ListPlot[pts]]Sample from PoissonPointProcess using the different methods:
reg = Ellipsoid[{0, 0}, {2, 1.5}];proc = PoissonPointProcess[3.5, 2];pts1 = RandomPointConfiguration[proc, reg, Method -> "Thinning"]Use Markov chain Monte Carlo method:
pts2 = RandomPointConfiguration[proc, reg, Method -> "MCMC"]Table[Show[RegionPlot[reg], ListPlot[k], AspectRatio -> Automatic], {k, {pts1, pts2}}]Estimate PoissonPointProcess:
pts = RandomPointConfiguration[PoissonPointProcess[60, 2], Disk[]]EstimatedPointProcess[pts, PoissonPointProcess[m, d]]N[%]Estimate PoissonPointProcess over a geo region:
sample = RandomPointConfiguration[PoissonPointProcess[Quantity[.005, 1 / "Kilometers" ^ 2], 2], Entity["Country", "Spain"]]EstimatedPointProcess[sample, PoissonPointProcess[m, d]]UnitConvert[%, 1 / "Kilometers" ^ 2]Find PointCountDistribution:
proc = PoissonPointProcess[30, 2];
reg = Disk[];PointCountDistribution[proc, reg]proc = PoissonPointProcess[Quantity[1 / 200, 1 / "Miles" ^ 2], 2];
reg = GeoDisk[Here, Quantity[3, "Miles"]];PointCountDistribution[proc, reg]Applications (3)
Suppose flaws in plywood occur on an average of one flaw per 50 square feet. Simulate the process of finding flaws on a per-square-foot basis:
pp = PoissonPointProcess[1 / 50, 2];
reg1 = Rectangle[{0, 0}, {100, 100}];
sample = RandomPointConfiguration[pp, reg1]ListPlot[sample]Find the probability that a 4-foot×8-foot sheet will have no flaws:
reg2 = Rectangle[{0, 0}, {4, 8}];Probability[x == 0, xPointCountDistribution[pp, reg2]]//NFor a round mirror with area 7.54 cm
, the probability of no flaws is 0.91. Using the same polishing process, another round mirror with an area of 19.50 cm
is fabricated. Assuming the flaws are independent and randomly located, find the probability of no flaws on the larger mirror:
flawProc = PoissonPointProcess[λ, 2];mirror1 = Disk[{0, 0}, Sqrt[7.54 / π]];Find the intensity of the flaw point process:
prob = Probability[x == 0, xPointCountDistribution[flawProc, mirror1]]sol = First[Solve[prob == 0.9100 && λ > 0, λ]]//QuietThe resulting mirror polishing defect process is then:
proc = flawProc /. solThe probability of no errors in the larger mirror:
mirror2 = Disk[{0, 0}, Sqrt[19.50 / π]];PDF[PointCountDistribution[proc, mirror2], 0]An LCD display has 1920×1080 pixels. A display is accepted if it has 15 or fewer faulty pixels. The probability that a pixel is faulty from production is 
and the faulty pixel positions are independent and random. Find the proportion of displays that are accepted:
faultProcess = PoissonPointProcess[5 10^-6, 2];display = Rectangle[{0, 0}, {1920, 1080}];Simulate the faulty pixel configuration:
samples = RandomPointConfiguration[faultProcess, display, 3]ListPlot[samples]Find the probability of no more than 15 faulty pixels in the display:
NProbability[n ≤ 15, nPointCountDistribution[faultProcess, display]]Find the pixel failure rate required to produce 4000×2000 pixel displays and still have an acceptance rate of at least 90%:
display2 = Rectangle[{0, 0}, {4000, 2000}];prob = Probability[n ≤ 15, nPointCountDistribution[PoissonPointProcess[λ, 2], display2]]Plot the acceptance rate as a function of the pixel failure rate:
LogLogPlot[prob, {λ, 10^-7, 10^-5}, GridLines -> All, Frame -> True, FrameLabel -> {"Pixel Failure Rate", None}, PlotLabel -> "LCD Acceptance Rate"]Find the maximal acceptable pixel failure rate:
Maximize[{λ, prob ≥ 0.90 && 10^-6 < λ < 2 * 10^-6}, λ, Reals]
CDF[PointCountDistribution[PoissonPointProcess[λ, 2], display2], 15] /. Last[%]Properties & Relations (11)
The number of points in a PoissonPointProcess is Poisson distributed:
PointCountDistribution[PoissonPointProcess[μ, 2], Disk[{0, 0}, r]]% == PoissonDistribution[μ RegionMeasure[Disk[{0, 0}, r]]]Simulate a PoissonPointProcess over a unit disk:
proc = PoissonPointProcess[10, 2];
reg = Disk[];sample = RandomPointConfiguration[proc, reg, 500]dist = PointCountDistribution[proc, reg]Compare the histogram of point counts with the PDF:
ns = sample["PointCountList"];
Show[Histogram[ns, {1}, PDF], DiscretePlot[PDF[dist, x], {x, 0, 100}, PlotStyle -> PointSize[Medium]]]Fit a PoissonDistribution to the point counts:
edist = EstimatedDistribution[ns, PoissonDistribution[a]]DistributionFitTest[ns, edist, "TestConclusion"]Test against the underlying distribution:
DistributionFitTest[ns, dist, "TestConclusion"]Compute void probabilities for a Poisson point process. For a disk:
PDF[PointCountDistribution[PoissonPointProcess[m, 2], Disk[]], 0]PDF[PointCountDistribution[PoissonPointProcess[m, 2], Rectangle[{0, 0}]], 0]PDF[PointCountDistribution[PoissonPointProcess[m, 3], Ball[]], 0]The probability of finding a point within distance 
of an arbitrary location:
proc = PoissonPointProcess[λ, 2];EmptySpaceF[proc, r]This equivalent to the CDF of RayleighDistribution:
CDF[RayleighDistribution[1 / Sqrt[(2 * π * λ)]], r]//Refine[#, r > 0]&Equivalently compute SurvivalFunction at 0 of PointCountDistribution:
dist = PointCountDistribution[proc, Disk[{0, 0}, r]];SurvivalFunction[dist, 0]Poisson point process is stationary—the intensity is translation invariant:
proc = PoissonPointProcess[m, 2];Point count distribution in a subregion:
subreg1 = Disk[{0, 0}, r];dist1 = PointCountDistribution[proc, subreg1]Point count distribution in the translated subregion:
subreg2 = TransformedRegion[subreg1, TranslationTransform[{a, b}]];dist2 = PointCountDistribution[proc, subreg2]dist1 === dist2Poisson point process is isotropic—the intensity is rotation around origin invariant:
proc = PoissonPointProcess[m, 2];Point count distribution in a subregion:
subreg1 = Disk[{0, 0}, r];dist1 = PointCountDistribution[proc, subreg1]Point count distribution in the translated subregion:
subreg2 = TransformedRegion[subreg1, RotationTransform[θ]];dist2 = PointCountDistribution[proc, subreg2]//Simplifydist1 === dist2PoissonPointProcess has the property of complete spatial randomness:
SeedRandom[1];
μ = 10;
sample = RandomPointConfiguration[PoissonPointProcess[μ, 2], Disk[], 200]ListPlot[sample, AspectRatio -> 1]Define left and right half-disks:
left = Disk[{0, 0}, 1, {Pi / 2, 3Pi / 2}];
right = Disk[{0, 0}, 1, {-Pi / 2, Pi / 2}];Create subset of points in each subregion:
subLeft = SpatialPointData[sample, left]subRight = SpatialPointData[sample, right]{ListPlot[subLeft, AspectRatio -> 2], ListPlot[subRight, AspectRatio -> 2]}Extract the number of points for each subregion:
nLeft = subLeft["PointCountList"];
nRight = subRight["PointCountList"];Test whether two samples are independent:
IndependenceTest[nLeft, nRight]IndependenceTest[nLeft, nRight, "TestConclusion"]Ripley's 
function for the Poisson point process has closed form and does not depend on the intensity:
proc = PoissonPointProcess[μ, d];RipleyK[proc, r]Plot the function for few dimensions:
Plot[Table[RipleyK[proc, r], {d, 1, 4}]//Evaluate, {r, 0, 1.3}, PlotLegends -> (Row[{#, "D"}]& /@ Range[4])]Besag's 
for the Poisson point process does not depend on intensity or dimensionality:
proc = PoissonPointProcess[μ, d];BesagL[proc, r]PairCorrelationG for the Poisson point process is constant:
PairCorrelationG[PoissonPointProcess[μ, d], r]EmptySpaceF and NearestNeighborG functions of a Poisson point process are identical:
proc = PoissonPointProcess[μ, d];EmptySpaceF[proc, r]NearestNeighborG[proc, r]%% - %They both are equivalent to the CDF of an ExponentialDistribution:
vol[d_, r_] := π ^ (d / 2) / Gamma[1 + d / 2]r ^ d;CDF[ExponentialDistribution[μ * vol[d, r] / r], r]% == EmptySpaceF[proc, r] == NearestNeighborG[proc, r]//Refine[#, r > 0]&InhomogeneousPoissonPointProcess with a constant intensity function is PoissonPointProcess:
proc2D = InhomogeneousPoissonPointProcess[Function[{x, y}, a], 2];The point count distribution in a disk:
disk = Disk[{0, 0}, r];Assuming[r > 0, PointCountDistribution[proc2D, disk]]Point count distribution for a corresponding Poisson point process in the same region:
Assuming[r > 0, PointCountDistribution[PoissonPointProcess[a, 2], disk]]proc3D = InhomogeneousPoissonPointProcess[Function[{x, y}, a], 3];ball = Ball[{0, 0, 0}, r];The point count distribution in a ball:
Assuming[r > 0, PointCountDistribution[proc3D, ball]]Point count distribution for a corresponding Poisson point process in the same region:
Assuming[r > 0, PointCountDistribution[PoissonPointProcess[a, 3], ball]]Text
Wolfram Research (2020), PoissonPointProcess, Wolfram Language function, https://reference.wolfram.com/language/ref/PoissonPointProcess.html.
CMS
Wolfram Language. 2020. "PoissonPointProcess." Wolfram Language & System Documentation Center. Wolfram Research. https://reference.wolfram.com/language/ref/PoissonPointProcess.html.
APA
Wolfram Language. (2020). PoissonPointProcess. Wolfram Language & System Documentation Center. Retrieved from https://reference.wolfram.com/language/ref/PoissonPointProcess.html