\documentclass[10pt]{article}
\usepackage{graphicx}
\usepackage{Sweave}
\usepackage{bm}
\usepackage[bottom=0.5cm, right=1.5cm, left=1.5cm, top=1.5cm]{geometry} 

% \VignetteIndexEntry{Summary of Recent Updates to the Spatstat Family}

% $Revision: 1.93 $ $Date: 2026/06/01 23:41:23 $

\newcommand{\pkg}[1]{\texttt{#1}}
\newcommand{\code}[1]{\texttt{#1}}
\newcommand{\R}{{\sf R}}
\newcommand{\spst}{\pkg{spatstat}}
\newcommand{\Spst}{\pkg{Spatstat}}

\begin{document}
\bibliographystyle{plain}

<<echo=FALSE,results=hide>>=
library(spatstat)
x <- read.dcf(file = system.file("DESCRIPTION", package = "spatstat"),
              fields = c("Version", "Date"))
sdate    <- as.character(x[,"Date"])
sversion <- as.character(x[,"Version"])
## recognise fractional version number
IsDevel <- function(ver) { length(unlist(package_version(ver))) > 3 }
sdevel   <- IsDevel(x[,"Version"])
options(useFancyQuotes=FALSE)
@ 

\title{Summary of recent updates to \spst}
\author{Adrian Baddeley, Rolf Turner and Ege Rubak}
\date{\spst\ version \Sexpr{sversion}, released on \Sexpr{sdate}}
\maketitle

\thispagestyle{empty}

<<echo=FALSE,results=hide>>=
readSizeTable <- function(fname) {
  if(is.null(fname) || !file.exists(fname)) return(NULL)
  a <- read.table(fname, header=TRUE)
  a$date <- as.Date(a$date)
  return(a)
}
getSizeTable <- function(packagename="spatstat", tablename="packagesizes.txt") {
  fname <- system.file("info", tablename, package=packagename)
  out <- readSizeTable(fname)
  if(is.null(out)) {
    fname <- system.file("doc", tablename, package=packagename)
    out <- readSizeTable(fname)
  }
  return(out)
}
RemoveDevel <- function(sizetable) {
  ## remove entries with fractional version numbers
  if(is.null(sizetable)) return(NULL)
  isdevel <- sapply(sizetable$version, IsDevel)
  st <- if(all(isdevel)) NULL else sizetable[!isdevel, , drop=FALSE]
  return(st)
}
counts <- c("nhelpfiles", "nobjects", "ndatasets", "Rlines", "srclines")
mergeSizeTables <- function(a, b, breakupdate, allow.devel=sdevel) {
  #' a is the running total for spatstat; b is a sub-package.
  #' breakupdate is the date when the code in b was removed from spatstat
  #' so that the size of 'b' must be added to 'a' for all dates >= breakupdate
  if(!allow.devel) b <- RemoveDevel(b)
  if(is.null(b)) return(a)
  adates <- a$date
  bdates <- b$date
  alldates <- sort(unique(c(adates,bdates)))
  if(missing(breakupdate)) breakupdate <- min(bdates)
  #' functions to determine, for any given date,
  #' the relevant (latest) row of the table
  aok <- rev(!duplicated(rev(adates)))
  arowfun <- approxfun(adates[aok], seq_along(adates)[aok], 
                       method="constant", f=0, rule=2, yleft=0)
  bok <- rev(!duplicated(rev(bdates)))
  browfun <- approxfun(bdates[bok], seq_along(bdates)[bok], 
                       method="constant", f=0, rule=2, yleft=0)
  result <- NULL
  for(k in seq_along(alldates)) {
    thedate <- alldates[k]
    i <- arowfun(thedate)
    j <- browfun(thedate)
    #' i > 0 because spatstat's founding date is earlier than any sub-package
    nextrow <- a[i, ]
    if(j > 0 && thedate >= breakupdate) {
      #' add contribution from 'b'
      nextrow[, counts] <- nextrow[, counts] + b[j, counts]
    }
    result <- rbind(result, nextrow)
  }
  return(result)
}
## Get histories of all sub-packages
## Package formerly known as 'spatstat'
z <- getSizeTable() 
## installed sub-packages - access via the installed sub-packages
zutils   <- getSizeTable("spatstat.utils")
zdata    <- getSizeTable("spatstat.data")
zunivar  <- getSizeTable("spatstat.univar")
zsparse  <- getSizeTable("spatstat.sparse")
zgeom    <- getSizeTable("spatstat.geom")
zrandom  <- getSizeTable("spatstat.random")
zexplore <- getSizeTable("spatstat.explore")
zmodel   <- getSizeTable("spatstat.model")
zlinnet  <- getSizeTable("spatstat.linnet")
## other sub-packages - access via stored copies of package size files
##       defunct package spatstat.core 
zcore    <- getSizeTable("spatstat", "spatstatcoresize.txt")
##       extension packages 
zlocal   <- getSizeTable("spatstat", "spatstatlocalsize.txt")
zgui     <- getSizeTable("spatstat", "spatstatguisize.txt")
zKnet    <- getSizeTable("spatstat", "spatstatKnetsize.txt")
## Merge histories starting at the 'split dates'
z <- mergeSizeTables(z, zutils,  "2017-03-22")
z <- mergeSizeTables(z, zdata,   "2017-09-23")
z <- mergeSizeTables(z, zsparse, "2020-11-04")
BigSplitDay <- "2020-12-14"
z <- mergeSizeTables(z, zgeom,   BigSplitDay)
z <- mergeSizeTables(z, zcore,   BigSplitDay)
z <- mergeSizeTables(z, zlinnet, BigSplitDay)
z <- mergeSizeTables(z, zrandom, "2022-02-12")
CoreSplitDay <- "2020-05-25"   # size of 'core' drops to 0 on this date
z <- mergeSizeTables(z, zexplore, CoreSplitDay)
z <- mergeSizeTables(z, zmodel,   CoreSplitDay)
z <- mergeSizeTables(z, zunivar,  "2024-04-21")
## extension packages: these never overlapped spatstat
z <- mergeSizeTables(z, zlocal)
z <- mergeSizeTables(z, zgui)
z <- mergeSizeTables(z, zKnet)
## Now summarise
currentcount <- z[nrow(z), counts]
bookcount    <- z[z$version == "1.42-0", counts]
changes <- currentcount - bookcount
newobj <- changes[["nobjects"]]
newdat <- changes[["ndatasets"]] + 2  # redwood3, shelling2
newcode  <- changes[["Rlines"]] + changes[["srclines"]]
bookcode <- bookcount[["Rlines"]] + bookcount[["srclines"]]
currentcode <- currentcount[["Rlines"]] + currentcount[["srclines"]]
growth <- signif((100 * newcode)/bookcode, digits=2)
@ %$


This is a summary of changes to the \spst\ package
that have occurred since the publication of the 
book \cite{baddrubaturn15} in 2015.
Since then, the \spst\ family has grown by \Sexpr{growth}\%,
including \Sexpr{newobj} new functions and \Sexpr{newdat} new datasets,
and now contains more than \Sexpr{10 * floor(currentcode/10000)},000 lines of code.
This document summarises the most important changes.

<<echo=FALSE,results=hide,fig=FALSE>>=
options(SweaveHooks=list(fig=function() par(mar=0.2+c(2,4,2,0))))
Plot <- function(fmla, ..., dat=z, ylim=NULL) {
  yvals <- eval(as.expression(fmla[[2]]), envir=dat)
  if(is.null(ylim)) ylim <- c(0, max(yvals))
  plot(fmla, ..., data=dat, type="n", xlab="", ylim=ylim, las=1)
}
@ 
\SweaveOpts{eps=TRUE}
\setkeys{Gin}{width=0.5\textwidth}

\centerline{
<<fig=TRUE,echo=FALSE,results=hide>>=
Plot((Rlines + srclines)/1000 ~ date, ylab="Lines of code (x 1000)", 
     main="Spatstat growth")
with(z, {
  polygon(c(date, rev(date)),
          c(srclines, rep(0, length(srclines)))/1000,
          angle=45, density=5, col="pink")
  polygon(c(date, rev(date)),
          c(srclines+Rlines, rev(srclines))/1000,
          angle=135, density=5, col="lightblue")
})
text(as.Date("2019-01-01"), 90, "R code", col="blue")
text(as.Date("2020-01-01"), 15, "C and C++ code", col="red")
lines((Rlines + srclines)/1000 ~ date, data=z, lwd=3)
lines(srclines/1000 ~ date, data=z, col="red")
@ 
}

\setcounter{tocdepth}{1}
\tableofcontents

\newpage


\newpage

\section{Version information}

The book \cite{baddrubaturn15}, published in December 2015,
covered \spst\ version \texttt{1.42-0}, released in May 2015.

<<echo=FALSE,results=hide>>=
## Tabulate latest version numbers of packages
vtable <- data.frame(package="spatstat", version=sversion, date=as.Date(sdate))
AppendVersion <- function(pkg, sizetable, v, allow.devel=sdevel) {
  if(!allow.devel) sizetable <- RemoveDevel(sizetable)
  if(is.null(sizetable)) return(v)
  lastrow <- sizetable[nrow(sizetable), , drop=FALSE]
  if(is.null(lastrow)) return(v)
  rbind(v, data.frame(package=pkg, version=lastrow[,"version"], date=as.Date(lastrow[,"date"])))
}
vtable <- AppendVersion("spatstat.utils", zutils, vtable)
vtable <- AppendVersion("spatstat.data", zdata, vtable)
vtable <- AppendVersion("spatstat.sparse", zsparse, vtable)
vtable <- AppendVersion("spatstat.univar", zunivar, vtable)
vtable <- AppendVersion("spatstat.geom", zgeom, vtable)
vtable <- AppendVersion("spatstat.random", zrandom, vtable)
vtable <- AppendVersion("spatstat.explore", zexplore, vtable)
vtable <- AppendVersion("spatstat.model", zmodel, vtable)
vtable <- AppendVersion("spatstat.linnet", zlinnet, vtable)
## move spatstat to the bottom
vtable <- rbind(vtable[-1, ], vtable[1, ])
## add extras
vtable <- AppendVersion("spatstat.local", zlocal, vtable)
vtable <- AppendVersion("spatstat.Knet", zKnet, vtable)
vtable <- AppendVersion("spatstat.gui", zgui, vtable)
@ 

The current versions of the \spst\ family of packages
(used to produce this document) are:

<<echo=FALSE>>=
print(vtable[,c(3,1,2)], row.names=FALSE)
@ 

\section{Package structure}

The original \pkg{spatstat} package grew to be very large.
It has now been split into a family of packages, to satisfy the requirements of CRAN. 

This should not affect the user:
existing code will continue to work in the same way.

Typing \code{library(spatstat)} will load the familiar
\pkg{spatstat} package which can be used as before.

\subsection{Sub-packages}

    Currently there are ten
    sub-packages, called 
    \pkg{spatstat.utils},
    \pkg{spatstat.data},
    \pkg{spatstat.univar},
    \pkg{spatstat.sparse},
    \pkg{spatstat.geom},
    \pkg{spatstat.random},
    \pkg{spatstat.explore},
    \pkg{spatstat.model},
    \pkg{spatstat.linnet},
    and \pkg{spatstat}.

    \begin{itemize}
    \item 
      The \code{spatstat} package now contains
      only documentation and introductory material.
      It provides beginner's introductions, latest news, 
      vignettes, interactive demonstration
      scripts, and a few help files summarising the package.
    \item 
      The \pkg{spatstat.data} package now contains all the datasets
      for \pkg{spatstat}.
    \item
      The \pkg{spatstat.utils} package
      contains basic utility functions for \pkg{spatstat}.
    \item
      The \pkg{spatstat.univar} package
      contains functions for estimating and manipulating
      probability distributions of one-dimensional random variables.
    \item
      The \pkg{spatstat.sparse} package
      contains functions for manipulating sparse arrays
      and performing linear algebra.
    \item
      The \pkg{spatstat.geom} package
      contains definitions of spatial objects (such as point patterns, windows
      and pixel images) and code which performs geometrical operations.
    \item
      The \pkg{spatstat.random} package
      contains functions for random generation of spatial patterns
      and random simulation of models.
    \item The \pkg{spatstat.explore} package contains the code for
      exploratory data analysis and nonparametric analysis
      of spatial data. 
    \item The \pkg{spatstat.model} package contains the code for model-fitting,
      model diagnostics, and formal inference.
    \item
      The \pkg{spatstat.linnet} package
      defines spatial data on a linear network,
      and performs geometrical operations 
      and statistical analysis on such data.
    \end{itemize}

    \noindent\textbf{Installing:}
    If you install \pkg{spatstat}, then the system will install all the 
    other sub-packages listed above.
    
    \noindent\textbf{Running:}
    If you type \code{library(spatstat)} in an \textsf{R} session,
    the system will automatically load 
    \pkg{spatstat.data}, \pkg{spatstat.univar}, \pkg{spatstat.geom}, \pkg{spatstat.random},
    \pkg{spatstat.explore}, \pkg{spatstat.model} and \pkg{spatstat.linnet}.
    It will also silently \textbf{``import''}
    \pkg{spatstat.utils} and \pkg{spatstat.sparse}.
    To access the functions in \pkg{spatstat.utils} directly, you would need to
    type \code{library(spatstat.utils)}. Similarly for \pkg{spatstat.sparse}.

    \subsection{Extension packages}
    
    There are also extension packages which provide additional capabilities
    and must be loaded explicitly when you need them. 
    Currently there are three extension packages, with a fourth in development:
    
    \begin{itemize}
    \item \pkg{spatstat.local} for local model-fitting, 
    \item \pkg{spatstat.Knet} provides additional code for
      analysing point patterns on a network.
    \item \pkg{spatstat.gui} containing interactive graphics
      functions,
    \item \pkg{spatstat.sphere} for analysing point patterns on a sphere
      (under development!)
    \end{itemize}

%\pagebreak

\section{Pr{\'e}cis of all changes}

Here is the text from the `overview' sections of 
the News and Release Notes for each update. 

\begin{itemize}
\item More methods for \texttt{intensity}
\item More methods for repulsion index \texttt{repul}.
\item Changed rule for converting bandwidths in pair correlation.
\item Improved handling of boundary pixels in \texttt{density()}, 
  \texttt{relrisk()}, \texttt{Smooth()}
\item Improved handling of boundary pixels in model predictions.
\item Improvements to rose diagrams.
\item Fiksel's bandwidth rule.
\item Faster calculation of Ripley's isotropic edge correction.
\item Random diffusion of points.
\item Random unrounding.
\item Truncated Poisson distribution.  
\item Improved handling of boundary pixels 
  when discretising a polygonal window.
\item Improved handling of `rejected' points.
\item Simulate a Markov chain with sparse transition matrix.

\item  Weighted sum of outer products in a 3D array or sparse array.
  
\item Distribution of a weighted sum of chi-squared random variables.
  
\item New generic \texttt{Lmodel} computes the theoretical $L$-function
  of a fitted model or theoretical model.

\item \texttt{envelope} method for determinantal point process models.

\item Specify the theoretical value of the summary function 
  in \texttt{envelope}.
  
\item Important changes to default settings for pair correlation functions.
  
\item More flexible interpretation of arguments \texttt{lambda = <ppm>}
  or \texttt{lambda = <lppm>}
  in inhomogeneous summary statistics

\item New options for multitype pair correlation functions.

\item More options for \texttt{simulate} argument in \texttt{envelope} methods.

\item Extended capability of \texttt{envelope.pp3}

\item Method of T.F. Cox for identifying dense and sparse regions of points.
  
\item New class of (theoretical) cluster process models

\item Inhomogeneous Poisson process in 3D.

\item Non-uniform random points in 3D.
    
\item Simple Sequential Inhibition in 3D.
  
\item Support function, Feret diameter, polar body, Voronoi flower.

\item Merge tiles in a tessellation.

\item Return squared nearest neighbour distances.
    
\item Bug fix in Minkowski sum.

\item Summary method for tessellations.
  

\item Identify threads in a network

\item Improved algorithm for integrating a function over a network.

\item Summary functions have argument \texttt{rmax}.
  
\item Diagnostic functions have argument \texttt{rmax}.
  
\item More support for long vectors (vectors with more than $2^{31}$ entries).
  
\item Waagepetersen's composite likelihood for cluster processes.  
  
\item Important changes to mark correlation function.
  
\item Convert a recursively partitioned point process model
  to a spatial tessellation.
  
\item Signed distance transform and signed distance function.
  
\item Spatial persistence index and cluster strength index.
  
\item Improvements to \texttt{profilepl} and \texttt{effectfun}.

\item Improvements to perspective plot of a function on a network.
  
\item Replicated point patterns on a linear network.
  
\item Diagnostics for a fitted point process model on a linear network.
  
\item \texttt{lppm} recognises local coordinates in the model formula.
  
\item Major extension of code for ROC curves.  

\item ROC curves for determinantal point process models.
    
\item Extended facilities for spatial logistic regression.

\item Level sets calculated using analytic geometry, for some functions.

\item Easier control over transparency of image plots.

\item Scramble the colours when plotting a point pattern 
  or line segment pattern.
  
\item Different discretisation rules supported in \texttt{slrm}.

\item Leave-one-pixel-out prediction in \texttt{slrm}.
  
\item Generate Gaussian random fields.

\item Lurking variable plot on a network.

\item Partial residual plot on a network.

\item Quadrat counting and quadrat tests on a linear network.

\item More geometrical operations on linear network objects.

\item Pixelwise arithmetic on a linear network.
  
\item Partial residuals for cluster process and Cox process models.

\item Extended facilities for spatial logistic regression.

\item Improvements to perspective views of images.

\item Missing or unavailable (NA) spatial objects
  are accepted by \texttt{solist} and \texttt{hyperframe}.
  
\item Missing or unavailable (NA) spatial objects
  are handled by \texttt{solapply}, \texttt{with.hyperframe}
  and by many low-level functions.

\item Summary functions handle NA objects.

\item Simulation of a fitted model in a different window is better supported.  
  
\item More options when simulating a fixed number of random points.  
  
\item \texttt{unnormdensity} returns the smoothing parameters used.  
  
\item Find centroids of tiles of a tessellation.

\item More options for converting a tessellation to an image.
  
\item Youden index.
  
  \item Shrinkage estimator in \texttt{Smooth.ppp}.

  \item Backgrounds for plots of point patterns.
  \item Connected components of polygonal windows.
  \item More options for disc windows.

  \item Interactively identify tiles of a tessellation.
  \item Interactively identify segments of a network.
  \item Interactively identify tiles of a tessellation on a network.
  \item \texttt{spatstatLocator} supports `snap' behaviour (rounding the
    clicked location to the nearest grid point). 
  \item \texttt{clickpoly} allows vertices to be `snapped' (rounded to
    the nearest grid point).

  \item Corrected unit of length in two datasets.
    
\item New options for defining nearest neighbours.

\item \texttt{im.apply} handles vector-valued functions.

\item Remove small holes from a window.
  
  \item Extension to weighted median and weighted quantiles.
  
  \item Shrinkage estimator of relative risk.

  \item Normalised relative risk.

  \item Extensions to cross-validated bandwidth selection for smoothing.
  
  \item Conditional simulation (fixed number of points)
    in log-Gaussian Cox processes and Neyman-Scott cluster processes.
    
  \item Nonlinear colour maps and symbol maps.

  \item Backgrounds for image plots.

  \item \texttt{quadratcount.ppp} supports 
    left-closed, right-open rectangular tiles. 
    
  \item More support for interpolated CDF objects

  \item Improvements to plotting of images, and arrays of images.

  \item More control over plotting of colour maps, symbol maps and texture maps.

  \item Hyperframes handle a \texttt{Surv} object as a single column.
    
  \item New dataset \texttt{meningitis}.
    
  \item New dataset \texttt{shelling}.

  \item Methods for functions which are constant on each tile of a tessellation.

  \item New estimator of pair correlation function.

  \item New methods for bandwidth selection for pair correlation estimation.
    
  \item Helper functions for measuring estimator performance.
    
  \item Conditional simulation in \texttt{rLGCP},
    \texttt{rThomas}, \texttt{rMatClust}, \texttt{rCauchy}, \texttt{rVarGamma}.
    
  \item Recognise powers of an integer.
    
  \item Prime factorisation computation improved.

  \item More support for \texttt{interpolatedCDF} objects.
    
  \item Nonlinear colour maps and symbol maps.
    
  \item Simulation of \texttt{zclustermodel} objects.
    
  \item Shortest path between two points on a network.
    
  \item Boundary-corrected kernel density estimation on the positive half-line.
    
  \item Relative risk estimation using diffusion.

  \item Smoothing using diffusion.
    
  \item Tessellations can have any kind of marks.
    
  \item Bandwidth selection by non-random bootstrap.
    
  \item More control over default colours.
    
  \item Perspective plot of spatial point pattern with numerical marks.
    
  \item Quantiles using linear approximation.
    
  \item Extract the knots (jump points) of a weighted CDF.

  \item List the history of all changes made to a function in spatstat.
    
  \item More efficient prime factorisation.
    
  \item Digits in the decimal representation of a number.

  \item Easier control over quadrature schemes.

  \item Some geometry code accelerated.
  
  \item Corrected format of \texttt{gorillas} dataset.

  \item The \spst\ family no longer depends on the packages 
    \pkg{maptools}, \pkg{sp} and \pkg{RandomFields}.

  \item geometry code accelerated.
    
  \item Spatially weighted median and quantile of mark values.
    
  \item Boyce index.
    
  \item code for fitting and simulating log-Gaussian Cox models has changed.

  \item New vignette on function objects (class \texttt{"fv"} and 
    \texttt{"envelope"})

   \item Vignette on shapefiles temporarily removed.

  \item Integration of functions.
    
  \item \texttt{clarkevans.test} modified.
    
\item Improvements to \texttt{envelope} methods.
  
\item Conditional simulation for Matern cluster process.

\item Improvements to \texttt{runifpoint} and \texttt{rpoispp}.  
  
\item Extension of distance transform algorithm.

\item Improvement to progress reports.
    
\item Suppress annoying warnings.
 
\item Changed the calculation of standard errors in \texttt{density.ppp}
  and \texttt{relrisk.ppp}.

\item Inline arithmetic for function tables (class \texttt{"fv"}) 
  and arrays (class \texttt{"fasp"})
\item 
  Standard error calculation for \texttt{Smooth.ppp} (experimental)
\item 
  multitype pair correlation functions can save numerator and denominator.
\item 
  multitype inhomogeneous $J$ functions.
\item 
  More support for automatic bandwidth selection.

\item Standard errors are now available for \texttt{ppm} models
    fitted using \texttt{gam}.
  \item \texttt{linearKinhom} and \texttt{linearpcfinhom} 
    now automatically estimate the intensity.

  \item \texttt{density.lpp} accepts bandwidth selection rules,
    and has a simple default bandwidth.
  
  \item Pair correlation functions allow more control over smoothing parameters.
    
  \item Extension to support for one-dimensional smoothing kernels.
    
  \item Improvements to \texttt{update} methods for point process models.

  \item New \texttt{update} methods for classes \texttt{dppm} and \texttt{rppm}.
    
  \item Generate truncated Poisson random variables.

  \item reciprocal moment of Poisson variable conditioned to be positive.
    
  \item Methods for \verb![[! and \verb![[<-! for hyperframes.

  \item Colour map for \textsf{pH} values.

  \item Restrict a colour map to a narrower range of values.

  \item Integral of a one-dimensional density estimate.
    
  \item \texttt{kppm} has been accelerated when 
    \texttt{method="palm"} or \texttt{"clik2"}.

  \item \texttt{kppm} can save the history of the optimisation algorithm.

  \item Faster algorithms for simulating cluster processes.
  
  \item Penalised model-fitting for Neyman-Scott cluster process models.

  \item Index of the strength of clustering
    in a Neyman-Scott cluster process model.
    
  \item Probability of having any siblings.

  \item More information is printed about Neyman-Scott cluster process models.
  
  \item Palm intensity diagnostic plot.
    
  \item Convert several factors or factor-valued images 
    to a common set of levels.
    
  \item Extension to \texttt{rjitter}

  \item Alternative to \texttt{rjitter}

  \item Quantile function as a function

  \item Periodic edge correction for \textit{K} function.

  \item Changed denominator in \textit{K} function and pair correlation function.
  \item Bandwidth selection for adaptive kernel estimation of intensity.

  \item U-shaped and inverted-U-shaped curves in \texttt{rhohat}.
    
  \item Radial cumulative integral of an image.
    
  \item New dataset \texttt{stonetools}.
    
  \item Regularized model-fitting in \texttt{ppm} and \texttt{kppm}.

  \item Residuals for recursively-partitioned models.
    
  \item Residuals for any observed point pattern and an estimate of
    its intensity.
    
  \item Weighted measures and weighted integrals.
    
  \item Improved approximation of intensity of Gibbs models.
    
  \item Experimental code to represent (theoretical) point process models
    
  \item  Extract more information about a point process model.

  \item kernel smoothing on a linear network.
    
  \item linear network $K$ function and pair correlation function
    based on Euclidean distance.

  \item inhomogeneous linear network $J$ function.

  \item Terminal vertices of a network.

  \item A point pattern on a network can be plotted as cross-ticks.
    
  \item The interactive graphics functions \texttt{iplot} and \texttt{istat}
    have been removed from \spst\ into a new 
    extension package \pkg{spatstat.gui}.

  \item The packages \pkg{tcltk} and \pkg{rpanel} are no longer 
    Suggested by \spst.
    
  \item \spst\ now Imports the package \pkg{spatstat.sparse}.
    
  \item \spst\ now Imports the package \pkg{spatstat.utils}.

  \item \spst\ now requires the package \pkg{spatstat.data} 
    which contains the datasets.

  \item \spst\ now suggests the package \pkg{fftwtools}.

   \item Conditional simulation in \texttt{kppm}.
  
  \item More diagnostics for spatial logistic regression models.

  \item Increased numerical stability in \texttt{kppm}.

  \item Simulation of the product shot noise Cox process.

   \item Information criteria for model selection in \texttt{kppm}.

   \item Estimation of the spatial covariance function of a pixel image

   \item Modified handling of covariates in \texttt{slrm}

   \item New options for \texttt{weighted.quantile}
   
   \item Buffer tessellation
    
   \item New function for jittering point patterns on a network.

   \item Extensions to \texttt{rhohat}

   \item \texttt{densityfun.ppp} handles query points outside original window

   \item Extension to \texttt{discretise}.

   \item Improvement to \texttt{densityEqualSplit}.

   \item summary method for spatial logistic regression models

   \item New options for \texttt{distmap.psp}

   \item Improved output in \texttt{summary.mppm}
    
  \item Increased speed for large datasets.

  \item Variance calculations handle larger datasets.

  \item Relative risk estimation on a network.
    
  \item Leave-one-out density estimation on a network.
    
  \item Add new vertices to a linear network.

  \item More support for multi-dimensional patterns.

  \item \texttt{predict.mppm} now works for multitype point process models.
    
  \item Improved handling of \texttt{newdata} in \texttt{predict.mppm}
    
  \item New datasets \texttt{concrete} and \texttt{btb}.
    
  \item Changed default value of \texttt{stringsAsFactors}.
    
   \item Function \texttt{lengths.psp} has been renamed \verb!lengths_psp!.

   \item Tessellations on a linear network can now have marks.

   \item More functions for manipulating tessellations on a linear network.
    
   \item New functions for simulating point processes on a linear network.

   \item Nearest Neighbour Index function can now return mark values.

   \item Index of repulsion strength for determinantal point process models.

   \item Nearest neighbours between two point patterns in any number of dimensions.
    
   \item More options for handling bad simulation outcomes in \texttt{envelope}.

   \item \texttt{mppm} accepts case weights.
     
   \item Bandwidth selectors warn about extreme values of bandwidth.
     
  \item Fast kernel estimation on a linear network using 2D kernels.

  \item Extension of Scott's rule for bandwidth selection.

  \item Cross-validated bandwidth selection on a linear network.
    
  \item Random thinning and random labelling of spatial patterns
    extended to different types of pattern.

  \item Confidence intervals for multitype $K$ function.

  \item Envelopes for balanced two-stage test
    
  \item Extensions to adaptive intensity estimators

  \item `Dartboard' tessellation using polar coordinates.
    
   \item Standard error calculation for inverse-distance weighting.
     
   \item Kernel estimate of intensity as a \texttt{function(x,y)}.

   \item Extract discrete and continuous components of a measure.

   \item Improvements and extensions to leverage and influence code.

   \item Plot a line segment pattern using line widths.

   \item Find connected components of each tile in a tessellation.

   \item Geometrical operations on \texttt{distfun} objects.

   \item Join vertices in a linear network.
    
   \item Distance map and contact distribution for 
     rectangular structuring element.
    
  \item Lurking variable plot for models fitted to several point patterns.
    
  \item New dataset \code{cetaceans}.
    
  \item Gamma correction for colour maps and image plots.

  \item Class \code{units} has been renamed \code{unitname} to avoid package collision.

  \item More support for tessellations.
    
  \item Fixed longstanding bug in leverage and influence diagnostics.
    
  \item Improvements and bug fixes for leverage and influence diagnostics.

  \item Tighter bounding box for \code{psp}, \code{lpp}, \code{linnet} objects.
    
  \item Improved layout in \code{plot.solist}

  \item Tools to increase colour saturation.

  \item Connected components of a 3D point pattern.
    
  \item Accelerated computations on linear networks.

  \item Accelerated simulation of determinantal point processes.

  \item Improved printing of 3D point patterns.
    
  \item Minor corrections to handling of unitnames.
    
  \item Improvements to \texttt{ppm} and \texttt{update.ppm}.
    
  \item Correction to \texttt{lohboot}
    
  \item Numerous bug fixes for linear networks code.
    
  \item Now handles disconnected linear networks.
    
  \item Effect function is now available for all types of fitted model.

  \item Geometric-mean smoothing.

  \item A model can be fitted or re-fitted to a sub-region of data.
    
  \item New fast algorithm for kernel smoothing on a linear network.

  \item Leverage and influence diagnostics extended to Poisson/Gibbs models
        fitted by logistic composite likelihood.

  \item Two-stage Monte Carlo test.
  
  \item Dirichlet/Voronoi tessellation on a linear network.

  \item Thinning of point patterns on a linear network.

  \item More support for functions and tessellations on a linear network.

  \item Bandwidth selection for pair correlation function.
  
  \item Pooling operations improved. 

  \item Operations on signed measures.

   \item Operations on lists of pixel images.

   \item Improved pixellation of point patterns.

   \item Stieltjes integral extended.

   \item Subset operators extended.

   \item Greatly accelerated \texttt{rmh} when using \texttt{nsave}

  \item Sufficient Dimension Reduction for point processes.

  \item Alternating Gibbs Sampler for point process simulation.

  \item New class of spatially sampled functions.

  \item ROC and AUC extended to other types of point patterns and models.

  \item More support for linear networks.

  \item More support for infinite straight lines.

  \item \spst\ now depends on the packages \pkg{nlme} and \pkg{rpart}.

  \item Important bug fix in \code{linearK}, \code{linearpcf}

  \item Changed internal format of \code{linnet} and \code{lpp} objects.

  \item Faster computation in linear networks.

  \item Bias correction techniques.
  
  \item Bounding circle of a spatial object.

  \item Option to plot marked points as arrows.

  \item Kernel smoothing accelerated.

  \item Workaround for bug in some graphics drivers affecting image orientation.

  \item Non-Gaussian smoothing kernels.

   \item Improvements to inhomogeneous multitype $K$ and $L$ functions.

   \item Variance approximation for pair correlation function.

   \item Leverage and influence for multitype point process models.

   \item Functions for extracting components of vector-valued objects.

  \item Recursive-partition point process models.

   \item Minkowski sum, morphological dilation and erosion with any shape.

  \item Minkowski sum also applicable to point patterns and line segment patterns.
    
   \item Important bug fix in Smooth.ppp
 
   \item Important bug fix in spatial CDF tests.

   \item  More bug fixes for replicated patterns.

   \item Simulate a model fitted to replicated point patterns.

   \item Inhomogeneous multitype $F$ and $G$ functions.

   \item Summary functions recognise \texttt{correction="all"}

   \item Leverage and influence code handles bigger datasets.

   \item More support for pixel images.

   \item Improved progress reports.

   \item New dataset \texttt{redwood3}

    \item Fixed namespace problems arising when spatstat is not loaded.

   \item Important bug fix in leverage/influence diagnostics for Gibbs models.

   \item Surgery with linear networks.
   
   \item Tessellations on a linear network.

   \item Laslett's Transform.

   \item Colour maps for point patterns with continuous marks
     are easier to define.

   \item Pair correlation function estimates can be pooled.

   \item Stipulate a particular version of a package.

   \item More support for replicated point patterns.
     
   \item More support for tessellations.

  \item More support for multidimensional point patterns and point processes.

   \item More options for one-sided envelopes.

   \item More support for model comparison.

   \item Convexifying operation.

   \item Subdivide a linear network.

   \item Penttinen process can be simulated (by Metropolis-Hastings or CFTP).

   \item Calculate the predicted variance of number of points.

   \item Accelerated algorithms for linear networks.

   \item Quadrat counting accelerated, in some cases.

   \item Simulation algorithms have been accelerated; simulation outcomes 
   are \emph{not} identical to those obtained from previous versions of \spst. 

   \item Determinantal point process models.

   \item Random-effects and mixed-effects models for replicated patterns.

   \item Dao-Genton test, and corresponding simulation envelopes.

   \item Simulated annealing and simulated tempering.

   \item spatstat colour tools now handle transparent colours.

   \item Improvements to \verb![! and \texttt{subset} methods

   \item Extensions to kernel smoothing on a linear network.

   \item Support for one-dimensional smoothing kernels.

   \item Mark correlation function may include weights.

   \item Cross-correlation version of the mark correlation function.

   \item Penttinen pairwise interaction model.

   \item Improvements to simulation of Neyman-Scott processes.

   \item Improvements to fitting of Neyman-Scott models.

   \item Extended functionality for pixel images.

   \item Fitted intensity on linear network

   \item Triangulation of windows.

   \item  Corrected an edge correction.
   \end{itemize}  
   
\section{New datasets}  

The following new datasets have been added.
These are now provided in the sub-package \pkg{spatstat.data}.

\begin{itemize}
\item \texttt{austates}: The states and large mainland territories of Australia
   represented as polygonal regions forming a tessellation.
 \item \texttt{redwood3}: a more accurate version of the \texttt{redwood} data.
 \item \texttt{cetaceans}: point patterns of whale and dolphin sightings.
 \item \texttt{concrete}: air bubbles in concrete.
 \item \texttt{btb}: bovine tuberculosis occurrences.
 \item \texttt{stonetools}: palaeolithic stone tools and bone fragments.
 \item \texttt{shelling}: artillery impacts in Ukraine.
 \item \texttt{meningitis}: meningitis cases in Germany.
\end{itemize}

\section{New classes}

The following new classes of objects may be of use.

\begin{itemize}
\item \texttt{clusterprocess}:
  Neyman-Scott-Cox cluster process
  model with specified values of the parameters.
\item \texttt{traj}:
    Trajectory (history of function evaluations) in a model
    that was fitted by optimisation.
\item \texttt{metric}: Class of distance metrics.
   An object of class \texttt{metric} represents a distance metric
   between points in two-dimensional space.
   See \texttt{help(metric.object)}.
\item \texttt{ssf}:
  Class of spatially sampled functions. 
  An object of class \texttt{"ssf"} represents a spatial function
  which has been evaluated or sampled at an irregular set of points.
  See \texttt{help(ssf)}.
\item \texttt{zclustermodel}:
  Experimental. An object of class \texttt{zclustermodel} represents a
    Neyman-Scott cluster point process model with specified parameter values
    (whereas \texttt{kppm} represents such a model fitted to data).
\item \texttt{zgibbsmodel}:
  Experimental. An object of class \texttt{zgibbsmodel} represents a
    Gibbs point process model with specified parameter values
    (whereas \texttt{ppm} represents such a model fitted to data).
\end{itemize}

\section{New Functions}

Following is a list of all the functions that have been added,
starting with the most recent additions.

\begin{itemize}
\item \texttt{intensity.kppm}: Intensity of a fitted cluster process
  or Cox process model.
\item \texttt{intensity.lppm}: Intensity of a fitted point process model
  on a linear network.
\item \texttt{intensity.mppm}: Intensity of a point process model
  fitted to multiple point patterns.
\item \texttt{repul.detpointprocfamily}:
  Repulsion index for determinantal point process model.
\item \texttt{repul.kppm}, \texttt{repul.clusterprocess}:
  Repulsion index for cluster process models and Cox models
  (gives negative value).
\item \texttt{repul.slrm}, \texttt{repul.rppm}:
  Repulsion index for spatial logistic regression models
  and recursive partition models (gives zero value)
\item \texttt{repul.ppm}, \texttt{repul.mppm}:
  Repulsion index for fitted Poisson or Gibbs models
  using Poisson-saddlepoint approximation.
\item \texttt{bw.fiksel}: Fiksel's (1988) rule for smoothing bandwidth for
    estimating the pair correlation function.
\item \texttt{rdiffuse}:
  Randomly perturb each point in a point pattern by diffusion.
\item \texttt{rUnround}, \texttt{rUnround.ppp}
  Random un-rounding of a discretised point pattern.
\item \texttt{dpoisnonzero}, \texttt{ppoisnonzero}, \texttt{qpoisnonzero}:
  Density, cumulative probability and quantile function for
  a Poisson random variable conditioned to be nonzero.
\item \texttt{dpoistrunc}, \texttt{ppoistrunc}, \texttt{qpoistrunc}
  Density, cumulative probability and quantile function for
  the truncated Poisson distribution.
\item \texttt{runSparseMarkovChain} (in \texttt{spatstat.sparse}):
  Generate simulated realisations of a Markov chain
  using a sparse matrix representation of the transition probability matrix.
\item \texttt{sumsymouter} (in \texttt{spatstat.sparse}):
  Weighted sum of outer products in a 3D array or sparse array.
\item \texttt{length.sparse3Darray}:
  method for \texttt{length} for sparse 3D arrays.
\item \texttt{dsocs}, \texttt{psocs}, \texttt{qsocs}, \texttt{rsocs}:
  Probability density function, cumulative probability distribution function,
    quantile function and random generator for a random variable
    which is a weighted Sum Of Chi-Squared random variables.
  \item \texttt{farebro}: Farebrother's Algorithm 
    for the cumulative probability of
    a weighted sum of non-central chi-squared variables.
\item \texttt{envelope.dppm}:
  Method for \texttt{envelope} for fitted models of class \texttt{"dppm"}
\item \texttt{Lmodel}, \texttt{Lmodel.kppm}, \texttt{Lmodel.dppm}, 
  \texttt{Lmodel.ppm}, \texttt{Lmodel.detpointprocfamily}:
  Given a point process model, return a function in the \textsl{R} language
  which computes the theoretical $L$-function of the model.
\item \texttt{Kmodel.clustermodel}, \texttt{pcfmodel.clustermodel}, 
  \texttt{Lmodel.clustermodel}:
    Calculate the theoretical $K$-function, $L$-function or pair correlation
    function for a model of class \texttt{"clustermodel"}.
\item \texttt{coxmap}:
  Given a point pattern, divide the spatial region into
  areas where the pattern is dense, sparse or neither,
  using the method of T.F. Cox (1979).
\item \texttt{rpoint3}:
    Random points in three dimensions with any probability density
\item \texttt{clusterprocess}:
  Create an object of class \texttt{clusterprocess}.
\item \texttt{clusterradius.clusterprocess}:
  Radius of the support of the offspring density of a cluster process model.
\item \texttt{predict.clusterprocess}:
  Calculate intensity of a cluster process model
\item \texttt{print.clusterprocess}:
  Print a cluster process model
\item \texttt{reach.clusterprocess}:
  Distance beyond which the pair correlation is effectively 1.
\item \texttt{simulate.clusterprocess}
    Generate simulated realisations of a cluster process model.
\item \texttt{mergeTiles}: Merge tiles in a tessellation.
\item \texttt{mergeTiles.lintess}: Merge tiles in a tessellation on a network.
\item \texttt{FeretDiamFun}:
  Create a function that computes the Feret diameter of a domain at any angle.
\item \texttt{FeretBox}:
  Compute the tightest rectangle enclosing a domain at any angle.
\item \texttt{minFeretDiam}, \texttt{maxFeretDiam}:
  Minimum or maximum Feret diameter of a domain
\item \texttt{SupportFun}
  Create a function that computes the support function of a domain.
\item \texttt{polarbody}
  Compute the polar body of a domain.
\item \texttt{voronoiFlower}
  Compute the Voronoi flower of a domain.
\item \texttt{summary.tess}, \texttt{print.summary.tess}
    Method for \texttt{summary} for tessellations.
\item \texttt{capitalise}: make the first letter of each word a capital letter.
\item \texttt{default.colourmap}: default colour map for a vector or factor.
\item \texttt{levelset}: new generic
\item \texttt{levelset.im}: level set of a pixel image
\item \texttt{levelset.distfun}: level set of a distance function.
\item \texttt{levelset.tessfun}: level set of a function created by
  \texttt{as.function.tess}.
\item \texttt{difflong}: lagged difference of long vector.
\item \texttt{persist}: spatial persistence index for a cluster process model.
\item \texttt{clusterstrength}: cluster strength index for
  a cluster process or Cox process model.
\item \texttt{as.tess.rppm}: convert a recursively partitioned 
  point process model to a spatial tessellation.
\item \texttt{formula.rppm}: extract the model formula
  of a recursively partitioned point process model.
\item \texttt{parres}: new generic function for partial residual plots.
\item \texttt{parres.ppm}: the original function \texttt{parres}
  has become the method \texttt{parres.ppm}.
\item \texttt{parres.kppm}: partial residual plot for
  fitted cluster process or Cox process models.
\item \texttt{diagnose}: new generic function for model diagnostics.
\item \texttt{diagnose.lppm}:
  diagnostic plots for point process model on a linear network.
\item \texttt{parres.lppm}:
  partial residual plot for point process model on a linear network.
\item \texttt{lurking.lppm}:
  Lurking variable plot for point process model on a linear network.
\item \texttt{lurking.lpp}:
  Lurking variable plot for point pattern on a linear network.
\item \texttt{residuals.lppm}:
  residual measure for point process model on a linear network.
\item \texttt{eem.lppm}:
  Stoyan-Grabarnik exponential energy weights diagnostic
  for point process model on a linear network.
\item \texttt{flipxy.linnet}:
  Swap $x$ and $y$ coordinates of a linear network
\item \texttt{flipxy.lpp}:
  Swap $x$ and $y$ coordinates of a point pattern on a linear network
\item \texttt{as.lintess}:
  Convert other kinds of data to a tessellation on a network.
\item \texttt{quadratcount.lpp}
  Method for quadrat counting on a linear network.
\item \texttt{quadrat.test.lpp}, \texttt{quadrat.test.lppm}
  Methods for quadrat test on a linear network.
\item \texttt{harmonise.linim}:
  Convert several images on a linear network to a common pixel grid.
\item \texttt{linim.apply}:
  Apply a function pixelwise to a list of images on a network.
\item \texttt{roc.dppm}: ROC curve for determinantal point process model.
\item \texttt{markequal}:     
  Mark equality function $e(r)$ for multitype point patterns.
\item \texttt{nnequal}, \texttt{nncount}:
  Summary functions for multitype point patterns
    based on the types of nearest neighbours.
\item \texttt{tolcon}: Tolerance contours for spatial relative risk.
\item \texttt{rGRFexpo}, \texttt{rGRFgauss}, \texttt{rGRFmatern}, 
  \texttt{rGRFstable}, \texttt{rGRFgencauchy}:
  generate a Gaussian random field.
\item \texttt{tile.centroids}:     
  Find the centroids of the tiles of a tessellation
  and return them as a point pattern.
\item \texttt{addROC}:
  Calculate partial ROC curve for adding a new covariate to a model.
\item \texttt{dropROC}:
    Calculate partial ROC curve for removing a covariate from a model.
  \item \texttt{dropply}, \texttt{addapply}:
    Consider all single-variable additions or deletions in a model.
\item \texttt{roc.rhohat}, \texttt{roc.cdftest}, \texttt{roc.bermantest}:
  calculate ROC curve from other kinds of data.
\item \texttt{roc.im}: calculate ROC curve from a pixel image
  such as an estimate of intensity.
\item \texttt{youden}: Youden statistic for ROC curves.
    
\item \texttt{fillholes.owin}: remove small holes from a window.
\item \texttt{NAobject}: create a missing object of a particular class.
\item \texttt{is.NAobject}: recognise whether an object is a missing object.
\item \texttt{is.na.hyperframe}: determine which entries in a hyperframe
  are missing (NA values or NA objects).
\item \texttt{as.ppp.NAobject}, \texttt{as.owin.NAobject}, 
  \texttt{as.im.NAobject}, \texttt{domain.NAobject}, \texttt{Frame.NAobject}, 
  \texttt{Window.NAobject}, \texttt{marks.NAobject}, \texttt{marks<-.NAobject}:
  methods for the generics \texttt{as.ppp}, \texttt{as.owin} etc, 
  which return an \texttt{NAobject}.
  \item \texttt{npoints.NAobject}, \texttt{nobjects.NAobject}:
    methods for the generics \texttt{npoints} and \texttt{nobjects},
    which return an \texttt{NA} integer value.
\item \texttt{c.layered}: concatenate layered objects, retaining their plot
  arguments.
\item \texttt{identify.tess}: interactively identify tiles of a tessellation.
\item \texttt{identify.linnet}: interactively identify segments of a network.
\item \texttt{identify.lintess}: interactively identify tiles of a tessellation
  on a network.
\item \texttt{as.linfun.linnet}: create a function on a linear network which
  maps each network segment to a specified value.
\item \texttt{plot.interpolatedCDF}, \texttt{print.interpolatedCDF}:
  methods for plotting and printing objects of class \texttt{"interpolatedCDF"}.
\item \texttt{simulate.zclustermodel}: method for simulating 
  objects of class \texttt{zclustermodel}.
\item \texttt{integral.tessfun}:
  Integral of a function which is constant on each tile of a tessellation.
\item \texttt{print.tessfun, plot.tessfun, as.tess.tessfun}:
  Methods for the class \texttt{"tessfun"} of functions which are constant
  on each tile of a tessellation.
\item \texttt{bw.bdh}:
  Adjust bandwidth of kernel estimate of pair correlation function,
  to account for inhomogeneity.

\item \texttt{bw.pcfinhom}:
    Cross-validation rule for selecting bandwidth of kernel estimate
    of (inhomogeneous) pair correlation function.

\item \texttt{ptwise.envelope, bias.envelope, RMSE.envelope}:
    Calculate pointwise statistics of the simulated function values
    in an envelope object.
\item     \texttt{ISE.envelope, ISB.envelope, IV.envelope}:
    Integrated squared error, integrated squared bias, integrated variance
    of the simulated function values in an envelope object.
\item \texttt{MISE.envelope}:
    Mean integrated squared error of the simulated function values
    in an envelope object.
    
\item \texttt{rev.colourmap}:
  Reverses the sequence of colour values in a colour map.
  A method for the generic \texttt{rev}.

\item \texttt{default.image.colours}, \texttt{reset.default.image.colours}:
  control the default colours used for plotting images in \texttt{spatstat}.

\item \texttt{shortestpath}:
  Find the shortest path between two specified points on a network,
    and return it as a line segment pattern.

\item \texttt{densityBC}:
  An extension of \texttt{stats::density.default} 
  that includes boundary corrections
    for truncation of the density to the positive half line.

\item \texttt{densityAdaptiveKernel.default}:
    Variable-bandwidth boundary-corrected kernel density estimation.
    
\item \texttt{relriskHeat}, \texttt{relriskHeat.ppp}:
    Relative risk estimation using diffusion.

  \item \texttt{bw.relriskHeatppp}:
    Bandwidth selection for \texttt{relriskHeat.ppp}
    
  \item \texttt{SmoothHeat}, \texttt{SmoothHeat.ppp}:
    Smoothing numerical values observed at points, using diffusion.
  
  \item \texttt{blurHeat}, \texttt{blurHeat.im}:
    Image smoothing using diffusion.

  \item \texttt{bw.taylor}: Bandwidth selection for kernel density estimation
  using Taylor's non-random bootstrap 
  
\item \texttt{latest.changes}:
  Lists the history of all changes that have been made to
  a particular function in the \texttt{spatstat} family of packages.

\item \texttt{persp.ppp}:  For a spatial point pattern with numeric marks,
    generate a perspective plot in which each data point is
    shown as a vertical spike, with height proportional to the mark value.
  
\item \texttt{knots.ewcdf}: 
  Method for generic \texttt{knots} for extracting the jump points of a weighted
    cumulative distribution function.
  
\item \texttt{firstdigit}, \texttt{lastdigit}, \texttt{ndigits}:
  digits in the decimal representation of a number.
  
\item \texttt{bw.abram.default}: Abramson adaptive bandwidths.
  Default method for \texttt{bw.abram}, applicable to numerical vectors.

\item \texttt{default.symbolmap.ppp}:  
  Algorithm for determining the graphical symbol map used by \texttt{plot.ppp}.
  
\item \texttt{summary.symbolmap}:
  Method for \texttt{summary} for symbol maps.
  
\item \texttt{SpatialMedian.ppp}, \texttt{SpatialQuantile.ppp}:
  spatially weighted median and quantile of mark values of a point pattern.
    
\item \texttt{boyce}: Boyce index and continuous Boyce index.
  
\item \texttt{densityAdaptiveKernel.splitppp}:
  A method for \texttt{densityAdaptiveKernel} for split point patterns.
  
\item \texttt{integral.fv}:
  Compute the integral of a function object.
  
\item \texttt{compileCDF}:
      Low level utility for calculating cumulative distribution function
    of distance variable. 

\item \texttt{Math.fv}, \texttt{Complex.fv}, \texttt{Summary.fv}, \texttt{Ops.fv}:
    Methods for arithmetic operations for function tables (class \texttt{"fv"})
\item \texttt{Math.fasp}, \texttt{Complex.fasp}, \texttt{Summary.fasp}, \texttt{Ops.fasp}:
    Methods for arithmetic operations for function arrays (class \texttt{"fasp"})
  \item \texttt{Gcross.inhom}, \texttt{Gdot.inhom}:
    Multitype $G$ functions for inhomogeneous point processes.
  \item 
    \texttt{Jcross.inhom}, \texttt{Jdot.inhom}, \texttt{Jmulti.inhom}:
    Multitype $J$ functions for inhomogeneous point processes.
  \item 
    \texttt{summary.bw.optim}, \texttt{print.summary.bw.optim}:
    Method for \texttt{summary} of optimised bandwidth objects 
    (class \texttt{bw.optim}).
    These are the objects produced by the bandwidth selection functions
    such as \texttt{bw.diggle}, \texttt{bw.scott}, \texttt{bw.pcf}

\item \texttt{psp2mask}:
  Function \texttt{as.mask.psp} has been renamed \texttt{psp2mask}.
  The old function \texttt{as.mask.psp} still exists but will soon be
  deprecated and later removed.
  
\item \texttt{update.dppm}:
    Update method for determinantal point process models.
    
\item \texttt{update.rppm}:
      Update method for recursively partitioned point process models.
  

    \item \verb![[.hyperframe!, \verb![[<-.hyperframe!:
    Methods for \verb![[! and \verb![[<-! for hyperframes.

    \item \texttt{pHcolourmap}, \texttt{pHcolour}:
    Colour map for values of pH

    \item \texttt{restrict.colourmap}:
    Restrict a colourmap to a narrower range of values.

    \item \texttt{integral.density}:
    Compute the integral of a one-dimensional kernel density estimate.

    \item \texttt{as.colourmap}:
    Extract colour information from an object.
    
\item \texttt{panysib}:
  Probability that a point in a cluster process has \emph{any} siblings.

\item \texttt{is.poissonclusterprocess}:
  Detects whether a given model is a Poisson cluster process
  (which includes Neyman-Scott processes).

\item \texttt{traj}, \texttt{print.traj}, \texttt{plot.traj}, 
  \texttt{lines.traj}:
    Extract, print and plot the trajectory of function evaluations.
    
\item \texttt{rpoisnonzero}:
Generate Poisson random variables conditioned to be positive.
    
\item \texttt{rpoistrunc}:
  Generate `truncated' Poisson random variables,
  conditioned to be greater than or equal to a specified minimum value.

  \item \texttt{recipEnzpois}:
        Calculate the first reciprocal moment of nonzero Poisson variable.
        
\item \texttt{rclusterBKBC}:
  (Advanced use) Internal algorithm to simulate any Neyman-Scott cluster
  process using either the naive, Brix-Kendall, or Baddeley-Chang algorithm.
    
\item \texttt{palmdiagnose}, \texttt{plot.palmdiag}:
  Palm intensity diagnostic plot for cluster process models
  proposed by Tanaka, Ogata and Stoyan.
    
\item \texttt{harmoniseLevels}: 
  Given several factors or factor-valued pixel images,
  convert them all to have the same set of factor levels.

\item \texttt{rexplode}: ``Explode'' a point pattern by randomly displacing each
    group of duplicated points to make a circular pattern
    around the original location. An alternative to \texttt{rjitter}.

\item \texttt{quantilefun}:
    Return a function that computes any quantiles of a given dataset.

\item \texttt{bw.CvL.adaptive}:
    Bandwidth selection for adaptive kernel estimation of intensity.

\item \texttt{radcumint}:
    Radial cumulative integral of an image.
    
\item \texttt{Smooth.lpp}: kernel smoothing on a linear network.
  
\item \texttt{residuals.rppm}:
  Residual measure for a recursively-partitioned point process model.
      
\item \texttt{residualMeasure}:
  Residual measure for any observed point pattern
  and any estimate of its intensity.
      
\item \texttt{linearKEuclid, linearpcfEuclid, linearKEuclidInhom, linearpcfEuclidInhom}:
  Linear network $K$ function and pair correlation function based on Euclidean distances.
  
\item \texttt{linearJinhom}:
  Inhomogeneous $J$ function on a linear network.

\item \texttt{terminalvertices}:
  Extract the terminal vertices of a linear network.

\item \texttt{bw.relrisk.lpp}:
    This function replaces \texttt{bw.relrisklpp}
    and is a method for the generic \texttt{bw.relrisk}.
  
\item \texttt{measureWeighted}: weighted version of a measure.
  
\item \texttt{harmonicmean, harmonicsum}:
  The harmonic mean of a set of numbers, calculated robustly.
  
\item \texttt{which.min.fair, which.max.fair} (in \texttt{spatstat.utils}):
  Find the location of the minimum or maximum entry in a vector;
  if there are multiple minima or maxima,
  choose one of them at random.
    
\item \texttt{hardcoredist}:
    Extract the hard core distance of a point process model.

  \item \texttt{interactionorder}:
    Extract the order of interpoint interaction of a point process model.
  
  \item \texttt{zgibbsmodel}:
    Experimental. Create an object of class \texttt{zgibbsmodel}.

  \item \texttt{print.zgibbsmodel}:
    Experimental. Print an object of class \texttt{zgibbsmodel}.

 
  \item \texttt{is.poisson.zgibbsmodel}, \texttt{is.stationary.zgibbsmodel}:
    Experimental. Methods for class \texttt{zgibbsmodel}.

  \item \texttt{indefinteg}: Numerically computes the indefinite integral of a function
  
  \item \texttt{framedist.pixels}: Computes distance from each pixel to the enclosing rectangle.
    
  \item \texttt{lurking.slrm}:
    Lurking variable plot for spatial logistic regression models.

  \item \texttt{eem.slrm}:
    Exponential energy marks for spatial logistic regression models.

  \item \texttt{eem.ppm}:
    Exponential energy marks for Gibbs and Poisson point process models
    (this function was previously called \texttt{eem}).
  
  \item \texttt{transformquantiles}:
    Transform the quantiles of a vector, matrix, array or pixel image.

  \item \texttt{convexmetric}:
    Distance metric based on a convex set.

  \texttt{invoke.metric}:
    Low level function to perform a desired operation using a given metric.

  \item \texttt{mean.ecdf, mean.ewcdf}
    Calculate the mean of an empirical cumulative distribution function.
    
  \item \texttt{rjitter.ppp}:
    \begin{itemize}
    \item 
      This function was previously called \texttt{rjitter}. It is now a method
      for the new generic function \texttt{rjitter}.
    \item 
      New argument \texttt{adjust} allows the default radius to be adjusted.
    \item 
      The resulting point pattern now has attribute \texttt{radius}.
    \item 
      If \texttt{retry=TRUE}, the resulting point pattern now has
      attribute \texttt{tries} which counts the number of trials that were 
      required.
    \end{itemize}
  
  \item \texttt{bufftess}:
    Distance buffer tessellation

   \item \texttt{ic}:
    Information criteria for model selection in ppm and kppm.
    Kindly contributed by Achmad Choiruddin, Jean-Francois Coeurjolly
    and Rasmus Waagepetersen.
    
   \item \texttt{rPSNCP}:
    Generate simulated realisations of the product shot noise Cox process.
    Contributed by Abdollah Jalilian, Yongtao Guan and Rasmus Waagepetersen.
    
   \item \texttt{spatcov}:
    Estimate the spatial covariance function of a pixel image.

   \item \texttt{summary.slrm}, \texttt{print.summary.slrm}
    Summary method for spatial logistic regression models

   \item \texttt{coef.summary.slrm}:
    Print the fitted coefficients, confidence interval and p-values
    for a spatial logistic regression model.

   \item \texttt{pairMean}:
    Compute the mean of a specified function of interpoint distance
    between random points in a window.

   \item \texttt{rjitterlpp}:
    Apply random displacements to the points on a linear network.
    
   \item \texttt{intersect.boxx}:
    Compute intersection of boxes in multi-dimensional space

    \item \texttt{scale.boxx}, \texttt{scale.ppx}:
    Methods for \texttt{scale} for boxes and patterns in multi-dimensional space

    \item \texttt{shift.boxx}, \texttt{shift.ppx}:
    Methods for \texttt{shift} for boxes and patterns in multi-dimensional space

    \item \texttt{is.boxx}:
    Determine whether an object is a multidimensional box
    
  \item \texttt{relrisk.lpp}: 
    nonparametric estimation of relative risk on a network.
    
  \item \texttt{bw.relrisklpp}: 
  Bandwidth selection for relative risk estimation on a network.
    
\item \texttt{bw.lppl}:
  Bandwidth selection for kernel density estimation
  of point patterns on a linear network,
  using likelihood cross-validation.
  
  \item  \texttt{densityfun.lpp}: a method for \texttt{densityfun}
    for point patterns on a linear network.
    
  \item \texttt{addVertices}:
    Add new vertices to a network, at locations outside the
    existing network.

  \item \verb!lengths_psp!: this is the new name of the 
    function \texttt{lengths.psp}, which had to be changed because of
    a conflict with the generic \texttt{lengths}.
  
    
  \item \texttt{densityEqualSplit}:
    The equal-split algorithm for kernel density estimation on a network
    is now visible as a separate function.

  \item \texttt{densityHeat}:
    The heat-equation algorithm for kernel density estimation on a network
    is now visible as a separate function. It has also been extended
    to computing leave-one-out density estimates at the data points.

   
  \item \texttt{hotrod}:
    Compute the heat kernel $\kappa(u,v)$ on a one-dimensional line segment.

  \item \texttt{heatkernelapprox}:
    Calculate an approximation to the value of the heat kernel
    on a network evaluated at the source point, $\kappa(u,u)$.
    
  \item \texttt{is.linim}: test whether an object is 
      a pixel image on a linear network (class \verb!"linim"!).
  
  \item \texttt{rcelllpp}:
    Simulate the cell point process on a linear network.
    
    \item \texttt{rSwitzerlpp}:
    Simulate the Switzer-type point process on a linear network.

    \item \texttt{intersect.lintess}:
    Form the intersection of two tessellations on a linear network.
    
    \item \texttt{chop.linnet}:
    Divide a linear network into tiles using infinite lines.
    
   \item \texttt{repairNetwork}:
     Detect and repair inconsistencies in internal data
     in a \texttt{linnet} or \texttt{lpp} object.

   \item \verb!marks<-.lintess!, \texttt{unmark.lintess}:
    Assign marks to the tiles of a tessellation on a linear network.

   \item \texttt{marks.lintess}:
    Extract the marks of the tiles of a tessellation on a linear network.
    
   \item \texttt{tilenames.lintess}:
    Extract the names of the tiles in a tessellation on a linear network

   \item \verb!tilenames<-.lintess!:
    Change the names of the tiles in a tessellation on a linear network

   \item \texttt{nobjects.lintess}:
    Count the number of tiles in a tessellation on a linear network

   \item \texttt{as.data.frame.lintess}:
    Convert a tessellation on a linear network into a data frame.

   \item \texttt{repul}:
    Repulsiveness index for a determinantal point process model.

   \item \texttt{reach.kppm}:
    Reach (interaction distance) for a Cox or cluster point process model.

   \item \texttt{summary.dppm}, \texttt{print.summary.dppm}:
    Summary method for determinantal point process models.

   \item \texttt{nncross.ppx}:
    Nearest neighbours between two point patterns in any number of dimensions.
  
    \item \texttt{rthinclumps}: 
          Divide a spatial region into clumps and randomly delete some of them.
          
    \item \texttt{densityQuick.lpp}:
    Fast kernel estimator of point process intensity on a network
    using 2D smoothing kernel.

    \item \texttt{data.lppm}:
      Extract the original point pattern  dataset (on a linear network)
      to which the model was fitted.

    \item \texttt{bw.scott.iso}:
    Isotropic version of Scott's rule (for point patterns in any dimension).  

    \item \texttt{bits.envelope}:
    Global simulation envelope corresponding to \texttt{bits.test},
    the balanced independent two-stage Monte Carlo test.
    
    \item \texttt{extrapolate.psp}:
    Extrapolate line segments to obtain infinite lines.
    
    \item \texttt{uniquemap}:
    Map duplicate points to unique representatives.
    Generic with methods for \texttt{ppp}, \texttt{lpp}, \texttt{ppx}
    
    \item \texttt{uniquemap.data.frame}, \texttt{uniquemap.matrix}:
    Map duplicate rows to unique representatives

    \item \texttt{localKcross}, \texttt{localLcross}, 
      \texttt{localKdot}, \texttt{localLdot},
    \texttt{localKcross.inhom}, \texttt{localLcross.inhom}:
    Multitype local $K$ functions.

  \item \texttt{polartess}: tessellation using polar coordinates.

  \item \texttt{densityVoronoi}: adaptive estimate of point process intensity
    using tessellation methods. 
  
  \item \texttt{densityAdaptiveKernel}: adaptive estimate of point process
    intensity using variable kernel methods.
    
  \item \texttt{bw.abram}: compute adaptive smoothing bandwidths using
    Abramson's rule.
  
  \item \texttt{coords.quad}: method for \texttt{coords}, to extract the 
    coordinates of the points in a quadrature scheme.
    
  \item \texttt{lineartileindex}: low-level function to classify points
    on a linear network according to which tile of a tessellation they
    fall inside.
    
    \item \texttt{markmarkscatter}: Mark--mark scatterplot.
      
    \item \texttt{bw.CvL}: Cronie-van Lieshout bandwidth selection
      for density estimation.
      
    \item \texttt{subset.psp}: subset method for line segment patterns.
      
    \item \texttt{densityfun}, \texttt{densityfun.ppp}:
    Compute a kernel estimate of intensity of a point pattern
    and return it as a function of spatial location.

    \item \texttt{as.im.densityfun}:
    Convert \texttt{function(x,y)} to a pixel image.


    \item \texttt{measureDiscrete}, \texttt{measureContinuous}:
    Extract the discrete and continuous components of a measure.

    \item \texttt{connected.tess}:
    Find connected components of each tile in a tessellation
    and make a new tessellation composed of these pieces.

    \item \texttt{dffit.ppm}:
    Effect change diagnostic \texttt{DFFIT} for spatial point process models.

    \item \texttt{shift.distfun}, \texttt{rotate.distfun}, 
      \texttt{reflect.distfun}, \texttt{flipxy.distfun},
    \texttt{affine.distfun}, \texttt{scalardilate.distfun}:
    Methods for geometrical operations on \texttt{distfun} objects.

    \item \texttt{rescale.distfun}:
    Change the unit of length in a \texttt{distfun} object.

    \item \texttt{plot.indicfun}:
    Plot method for indicator functions created by \texttt{as.function.owin}.

    \item \texttt{Smooth.leverage.ppm}, \texttt{Smooth.influence.ppm}:
    Smooth a leverage function or an influence measure.

    \item \texttt{integral.leverage.ppm}, \texttt{integral.influence.ppm}:
    Compute the integral of a leverage function or an influence measure.

    \item \texttt{mean.leverage.ppm}:
    Compute the mean value of a leverage function.

    \item \texttt{rectdistmap}:
    Distance map using rectangular metric.
    
    \item \texttt{rectcontact}:
    Contact distribution function using rectangular structuring element.

    \item \texttt{joinVertices}:
    Join specified vertices in a linear network.
    
    \item \code{summary.ssf}:
      Summary method for a spatially sampled function (class \code{ssf}).
      
    \item \code{unstack.tess}:
    Given a tessellation with multiple columns of marks,
    take the columns one at a time, and return a list of tessellations,
    each carrying only one of the original columns of marks.
      
    \item \code{contour.leverage.ppm}:
    Method for \code{contour} for leverage functions of class 
    \code{leverage.ppm}
    
    \item \code{lurking}:
    New generic function for lurking variable plots.

    \item \code{lurking.ppp}, \code{lurking.ppm}:
    These are equivalent to the original function \code{lurking}.
    They are now methods for the new generic \code{lurking}.

    \item \code{lurking.mppm}:
    New method for class \code{mppm}.
    Lurking variable plot for models fitted to several point patterns.

    \item \code{print.lurk}:
    Prints information about the object returned by the function 
    \code{lurking}
    representing a lurking variable plot.

    \item \code{model.matrix.mppm}:
    Method for \code{model.matrix} for models of class \code{mppm}.

    \item \code{test.crossing.psp},  \code{test.selfcrossing.psp}:
    Previously undocumented functions for testing whether segments cross.
    
    \item \code{to.saturated}:
    Convert a colour value to the corresponding fully-saturated colour.

    \item \code{intensity.psp}:
    Compute the average total length of segments per unit area.

    \item \code{boundingbox.psp}:
    Bounding box for line segment patterns.
    This produces a tighter bounding box than the previous default behaviour.

    \item \code{boundingbox.lpp}:
    Bounding box for point patterns on a linear network.
    This produces a tighter bounding box than the previous default behaviour.

    \item \code{boundingbox.linnet}:
    Bounding box for a linear network.
    This produces a tighter bounding box than the previous default behaviour.

    \item \verb!"Frame<-.default"!:
    New default method for assigning bounding frame to a spatial object.

    \item \code{connected.pp3}:
    Connected components of a 3D point pattern.

    \item \code{colouroutputs}, \verb!"colouroutputs<-"!:
    Extract or assign colour values in a colour map.
    (Documented a previously-existing function)

  \item \texttt{fitin.profilepl}:
    Extract the fitted interaction from a model fitted by profile likelihood.
    
    \item \verb![<-.linim!:  
      Subset assignment method for pixel images on a linear network.
      
    \item \texttt{nnfromvertex}:
    Given a point pattern on a linear network,
    find the nearest data point from each vertex of the network.
    
    \item \texttt{tile.lengths}:
    Calculate the length of each tile in a tessellation on a network.

    \item \texttt{text.ppp}, \texttt{text.lpp}, \texttt{text.psp}:
    Methods for \texttt{text} for spatial patterns.
  
  \item \texttt{as.data.frame.envelope}:
    Extract function data from an envelope object,
    including the functions for the simulated data ('simfuns')
    if they were saved.

    \item \texttt{is.connected}, \texttt{is.connected.default}, 
      \texttt{is.connected.linnet}:
    Determines whether a spatial object consists of
    one topologically connected piece, or several pieces.

    \item \texttt{is.connected.ppp}:
    Determines whether a point pattern is connected after
    all pairs of points closer than distance R are joined.

    \item \texttt{hist.funxy}:
    Histogram of values of a spatial function.

    \item \texttt{model.matrix.ippm}:
    Method for \texttt{model.matrix} which allows computation of
    regular and irregular score components.

    \item \texttt{harmonise.msr}:
    Convert several measures (objects of class \texttt{msr})
    to a common quadrature scheme.
    
    \item \texttt{bits.test}:
    Balanced Independent Two-Stage Monte Carlo test,
    an improvement on the Dao-Genton test.
    
    \item \texttt{lineardirichlet}:
    Computes the Dirichlet-Voronoi tessellation associated with a
    point pattern on a linear network.

    \item \texttt{domain.lintess}, \texttt{domain.linfun}:
    Extract the linear network from a
    \texttt{lintess} or \texttt{linfun} object.

    \item \texttt{summary.lintess}:
    Summary of a tessellation on a linear network.

    \item \texttt{clicklpp}:
    Interactively add points on a linear network.
    
    \item \texttt{envelopeArray}:
    Generate an array of envelopes
    using a function that returns \texttt{fasp} objects.

    \item \texttt{bw.pcf}:
      Bandwidth selection for pair correlation function.

    \item \texttt{grow.box3}:
    Expand a three-dimensional box.
    
    \item \texttt{hexagon}, \texttt{regularpolygon}:
    Create regular polygons.

    \item \texttt{Ops.msr}:
    Arithmetic operations for measures.

    \item \texttt{Math.imlist}, \texttt{Ops.imlist}, 
      \texttt{Summary.imlist}, \texttt{Complex.imlist}:
    Arithmetic operations for lists of pixel images.

    \item \texttt{measurePositive}, \texttt{measureNegative}, 
      \texttt{measureVariation}, \texttt{totalVariation}:
    Positive and negative parts of a measure, and variation of a measure.

    \item \texttt{as.function.owin}:
    Convert a spatial window to a \texttt{function(x,y)}, 
    the indicator function.

    \item \texttt{as.function.ssf}:
    Convert an object of class \texttt{ssf} to a \texttt{function(x,y)}

    \item \texttt{as.function.leverage.ppm}
    Convert an object of class \texttt{leverage.ppm} to a \texttt{function(x,y)}

  \item \texttt{sdr}, \texttt{dimhat}:
    Sufficient Dimension Reduction for point processes.

    \item \texttt{simulate.rhohat}:
    Simulate a Poisson point process with the
    intensity estimated by \texttt{rhohat}.

    \item \texttt{rlpp}:
    Random points on a linear network with a specified probability density.

    \item \texttt{cut.lpp}:
    Method for \texttt{cut} for point patterns on a linear network.

    \item \texttt{has.close}:
    Faster way to check whether a point has a close neighbour.

    \item \texttt{psib}:
    Sibling probability (index of clustering strength in a cluster process).
    
    \item \texttt{rags}, \texttt{ragsAreaInter}, \texttt{ragsMultiHard}:
    Alternating Gibbs Sampler for point processes.

    \item \texttt{bugfixes}:
      List all bug fixes in recent versions of a package.
      
    \item \texttt{ssf}:
    Create a spatially sampled function

    \item \texttt{print.ssf}, \texttt{plot.ssf}, \texttt{contour.ssf}, 
      \texttt{image.ssf}:
    Display a spatially sampled function

    \item \texttt{as.im.ssf}, \texttt{as.ppp.ssf}, \texttt{marks.ssf}, 
      \verb!marks<-.ssf!, \texttt{unmark.ssf}, \verb![.ssf!, \texttt{with.ssf}:
    Manipulate data in a spatially sampled function

    \item \texttt{Smooth.ssf}:
    Smooth a spatially sampled function 

    \item \texttt{integral.ssf}:
    Approximate integral of spatially sampled function

    \item \texttt{roc.kppm}, \texttt{roc.lppm}, \texttt{roc.lpp}:
      Methods for \texttt{roc} for fitted models of class \texttt{"kppm"} and 
      \texttt{"lppm"} and point patterns of class \texttt{"lpp"}

    \item \texttt{auc.kppm}, \texttt{auc.lppm}, \texttt{auc.lpp}:
      Methods for \texttt{auc} for fitted models of class \texttt{"kppm"} and 
      \texttt{"lppm"} and point patterns of class \texttt{"lpp"}
      
    \item \texttt{timeTaken}:
    Extract the timing data from a \texttt{"timed"} object or objects.

    \item \texttt{rotate.infline}, 
      \texttt{shift.infline}, \texttt{reflect.infline}, 
      \texttt{flipxy.infline}:
    Geometrical transformations for infinite straight lines.

    \item \texttt{whichhalfplane}:
    Determine which side of an infinite line a point lies on.

    \item \texttt{matrixpower}, \texttt{matrixsqrt}, \texttt{matrixinvsqrt}:
    Raise a matrix to any power.

    \item \texttt{points.lpp}:
    Method for \texttt{points} for point patterns on a linear network.

    \item \texttt{pairs.linim}:
    Pairs plot for images on a linear network.

    \item \texttt{closetriples}:
    Find close triples of points.
    
    \item \texttt{anyNA.im}:
    Method for \texttt{anyNA} for pixel images.

    \item \texttt{bc}:
    Bias correction (Newton-Raphson) for fitted model parameters. 

    \item \texttt{rex}:
    Richardson extrapolation for numerical integrals and 
    statistical model parameter estimates. 

    \item \texttt{boundingcircle}, \texttt{boundingcentre}:
    Find the smallest circle enclosing a window or point pattern.

    \item \verb![.linim! : 
    Subset operator for pixel images on a linear network.

    \item \texttt{mean.linim}, \texttt{median.linim}, \texttt{quantile.linim}:
    The mean, median, or quantiles of pixel values in a 
    pixel image on a linear network.

  \item \texttt{weighted.median}, \texttt{weighted.quantile}:
    Median or quantile of numerical data with associated weights.

  \item \verb!"[.linim"!:
    Subset operator for pixel images on a linear network.

  \item \texttt{mean.linim}, \texttt{median.linim}, \texttt{quantile.linim}:
    The mean, median, or quantiles of pixel values in a 
    pixel image on a linear network.
  
  \item \texttt{boundingcircle}, \texttt{boundingcentre}:
   Smallest circle enclosing a spatial object.

 \item \texttt{split.msr}:
    Decompose a measure into parts.

  \item \texttt{unstack.msr}:
    Decompose a vector-valued measure into its component measures.

  \item \texttt{unstack.ppp}, \texttt{unstack.psp}, \texttt{unstack.lpp}:
    Given a spatial pattern with several columns of marks,
    separate the columns and return a list of spatial patterns, 
    each having only one column of marks.

 \item \texttt{kernel.squint}:
    Integral of squared kernel, for the kernels used in density estimation.

 \item \texttt{as.im.data.frame}:
  Build a pixel image from a data frame of coordinates and pixel values.

\item \texttt{covering}:
    Cover a window using discs of a given radius.

\item \texttt{dilationAny}, \texttt{erosionAny}, \verb!%(-)%! :
    Morphological dilation and erosion by any shape.

\item \texttt{FmultiInhom}, \texttt{GmultiInhom}
  Inhomogeneous multitype/marked versions of the summary functions 
  \texttt{Fest}, \texttt{Gest}.

\item \texttt{kernel.moment}
    Moment or incomplete moment of smoothing kernel.

\item \texttt{MinkowskiSum}, \verb!%(+)%!: 
    Minkowski sum of two windows: \verb!A %(+)% B!, 
    or \texttt{MinkowskiSum(A,B)}

\item \texttt{nobjects}:
  New generic function for counting the number of 'things' in a dataset.
  There are methods for \texttt{ppp}, \texttt{ppx}, \texttt{psp}, \texttt{tess}.

 \item \texttt{parameters.interact}, \texttt{parameters.fii}:
    Extract parameters from interpoint interactions.
    (These existing functions are now documented.)

 \item \texttt{ppmInfluence}:
  Calculate \texttt{leverage.ppm}, \texttt{influence.ppm} and 
  \texttt{dfbetas.ppm} efficiently.

  \item \texttt{rppm}, \texttt{plot.rppm}, \texttt{predict.rppm}, 
    \texttt{prune.rppm}:
    Recursive-partition point process models.

 \item \texttt{simulate.mppm}
   Simulate a point process model fitted to replicated point patterns.

 \item \texttt{update.interact}:
    Update the parameters of an interpoint interaction.
    [This existing function is now documented.]

 \item \texttt{where.max}, \texttt{where.min}
    Find the spatial location(s) where a pixel image achieves its
    maximum or minimum value.
    
 \item \texttt{compileK}, \texttt{compilepcf}:
   make a $K$ function or pair correlation function
   given the pairwise distances and their weights.
   [These existing internal functions are now documented.]
    
  \item \texttt{laslett}:
  Laslett's Transform.

\item \texttt{lintess}: 
  Tessellation on a linear network.

\item \texttt{divide.linnet}:
  Divide a linear network into pieces demarcated by a point pattern.

\item \texttt{insertVertices}:
  Insert new vertices in a linear network.

\item \texttt{thinNetwork}:
  Remove vertices and/or segments from a linear network etc.

\item \texttt{connected.linnet}:
  Find connected components of a linear network.

\item \texttt{nvertices}, \texttt{nvertices.linnet}, \texttt{nvertices.owin}:
  Count the number of vertices in a linear network 
  or vertices of the boundary of a window.

\item \texttt{as.data.frame.linim}, \texttt{as.data.frame.linfun}:
  Extract a data frame of spatial locations and function values
  from an object of class \texttt{linim} or \texttt{linfun}.

\item \texttt{as.linfun}, \texttt{as.linfun.linim}, \texttt{as.linfun.lintess}:
  Convert other kinds of data to a \texttt{linfun} object.

\item \texttt{requireversion}:
    Require a particular version of a package
    (for use in stand-alone R scripts).

  \item \texttt{as.function.tess}:
   Convert a tessellation to a \texttt{function(x,y)}. The function value
   indicates which tile of the tessellation contains the point $(x,y)$.

   \item \texttt{tileindex}:
   Determine which tile of a tessellation contains a given point $(x,y)$.

   \item \texttt{persp.leverage.ppm}:
   Method for persp plots for objects of class \texttt{leverage.ppm}

   \item \texttt{AIC.mppm}, \texttt{extractAIC.mppm}:
   AIC for point process models fitted to replicated point patterns.

   \item \texttt{nobs.mppm}, \texttt{terms.mppm}, \texttt{getCall.mppm}:
   Methods for point process models fitted to replicated point patterns.

  \item \texttt{rPenttinen}:
    Simulate the Penttinen process using perfect simulation.

  \item \texttt{varcount}:
    Given a point process model, compute the predicted variance
    of the number of points falling in a window.

  \item \texttt{inside.boxx}:
    Test whether multidimensional points lie inside a specified 
    multidimensional box.

  \item \texttt{lixellate}:
    Divide each segment of a linear network into smaller segments.

  \item \texttt{nsegments.linnet}, \texttt{nsegments.lpp}:
     Count the number of line segments in a linear network.

  \item \texttt{grow.boxx}:
     Expand a multidimensional box.

   \item \texttt{deviance.ppm}, \texttt{deviance.lppm}:
     Deviance for a fitted point process model.

   \item \texttt{pseudoR2}:
     Pseudo-R-squared for a fitted point process model.

   \item \texttt{tiles.empty}
     Checks whether each tile of a tessellation is empty or nonempty.

   \item \texttt{summary.linim}:
     Summary for a pixel image on a linear network.
     
\item Determinantal Point Process models:
  \begin{itemize}
  \item \texttt{dppm}:
    Fit a determinantal point process model.
  \item \texttt{fitted.dppm}, \texttt{predict.dppm}, \texttt{intensity.dppm}:
    prediction for a fitted determinantal point process model.
  \item 
    \texttt{Kmodel.dppm}, \texttt{pcfmodel.dppm}: 
    Second moments of a determinantal point process model.
  \item
    \texttt{rdpp}, \texttt{simulate.dppm}:
    Simulation of a determinantal point process model.
  \item \texttt{logLik.dppm}, \texttt{AIC.dppm}, \texttt{extractAIC.dppm}, 
    \texttt{nobs.dppm}: Likelihood and AIC for 
    a fitted determinantal point process model.
  \item
    \texttt{print.dppm}, \texttt{reach.dppm}, \texttt{valid.dppm}: 
    Basic information about a \texttt{dpp} model.
  \item \texttt{coef.dppm}, \texttt{formula.dppm}, \texttt{print.dppm}, 
    \texttt{terms.dppm}, \texttt{labels.dppm},
    \texttt{model.frame.dppm}, \texttt{model.matrix.dppm}, 
    \texttt{model.images.dppm},  \texttt{is.stationary.dppm}, 
    \texttt{reach.dppm}, \texttt{unitname.dppm}, \verb!unitname<-.dppm!, 
    \texttt{Window.dppm}: Various methods for \texttt{dppm} objects.
  \item \texttt{parameters.dppm}: Extract meaningful list of model parameters.
  \item \texttt{objsurf.dppm}: Objective function surface of 
    a \texttt{dppm} object. 
  \item \texttt{residuals.dppm}: Residual measure for a \texttt{dppm} object.
  \end{itemize}

\item Determinantal Point Process model families:
  \begin{itemize}
  \item \texttt{dppBessel}, \texttt{dppCauchy}, 
    \texttt{dppGauss}, \texttt{dppMatern}, \texttt{dppPowerExp}:
    Determinantal Point Process family functions.
  \item \texttt{detpointprocfamilyfun}:
    Create a family function.
  \item    
    \texttt{update.detpointprocfamily}: Set parameter values in a
    determinantal point process model family.
  \item
    \texttt{simulate.dppm}:   Simulation.
  \item \texttt{is.stationary.detpointprocfamily}, 
   \texttt{intensity.detpointprocfamily}, \texttt{Kmodel.detpointprocfamily}, 
   \texttt{pcfmodel.detpointprocfamily}: Moments.
 \item \texttt{dim.detpointprocfamily}, \texttt{dppapproxkernel}, 
   \texttt{dppapproxpcf}, \texttt{dppeigen}, 
   \texttt{dppkernel}, \texttt{dppparbounds}, \texttt{dppspecdenrange}, 
   \texttt{dppspecden}:
   Helper functions.
 \end{itemize}

\item \texttt{dg.envelope}:
   Simulation envelopes corresponding to Dao-Genton test.

 \item \texttt{dg.progress}:
   Progress plot (envelope representation) for the Dao-Genton test.

 \item \texttt{dg.sigtrace}: significance trace for the Dao-Genton test.

 \item \texttt{markcrosscorr}:
   Mark cross-correlation function for point patterns with
   several columns of marks.

 \item \texttt{rtemper}:
   Simulated annealing or simulated tempering.

 \item \texttt{rgb2hsva}:
   Convert RGB to HSV data, like \texttt{rgb2hsv}, but preserving transparency.

 \item \texttt{superimpose.ppplist}, \texttt{superimpose.splitppp}:
   New methods for 'superimpose' for lists of point patterns.

 \item \texttt{dkernel}, \texttt{pkernel}, \texttt{qkernel}, \texttt{rkernel}:
   Probability density, cumulative probability, quantiles
   and random generation from distributions used in basic one-dimensional
   kernel smoothing.

 \item \texttt{kernel.factor}:
   Auxiliary calculations for one-dimensional kernel smoothing.

 \item \texttt{spatdim}:
   Spatial dimension of any object in the \spst\ package.

 \item \texttt{as.boxx}:
   Convert data to a multi-dimensional box.

 \item \texttt{intensity.ppx}:
   Method for \texttt{intensity} for multi-dimensional
   space-time point patterns.

 \item \texttt{fourierbasis}:
   Evaluate Fourier basis functions in any number of dimensions.

 \item \texttt{valid}:
   New generic function, with methods 
   \texttt{valid.ppm}, \texttt{valid.lppm}, \texttt{valid.dppm}.
   
 \item \texttt{emend}, \texttt{emend.ppm}, \texttt{emend.lppm}:
   New generic function with methods for \texttt{ppm} and \texttt{lppm}.
   \texttt{emend.ppm} is equivalent to \texttt{project.ppm}.

 \item \texttt{Penttinen}:
   New pairwise interaction model.

  \item \texttt{quantile.density}:
   Calculates quantiles from kernel density estimates.

  \item \texttt{CDF.density}:
   Calculates cumulative distribution function from kernel density estimates.

\item \texttt{triangulate.owin}: decompose a spatial window into triangles.
\item \texttt{fitted.lppm}: fitted intensity values for a point process
  on a linear network.
  
   \item \texttt{parameters}:
   Extract all parameters from a fitted model.

 \end{itemize}
 
 
\section{Alphabetical list of changes}

Here is a list of all changes made to existing functions,
listed alphabetically.

\begin{itemize}
%%A
  
\item \texttt{adaptive.density}:
  This function can now perform adaptive estimation by three methods: 
  tessellation-based methods, variable-bandwidth kernel estimation,
  and nearest-neighbour intensity estimation.
  The calculations are performed by \texttt{densityVoronoi},
  \texttt{densityAdaptiveKernel} or \texttt{nndensity}.
  
\item \texttt{affine.owin}:
  Allows transformation matrix to be singular, if the window is polygonal.

\item \texttt{alltypes}:
    If \texttt{envelope=TRUE} and the envelope computation reaches the
    maximum permitted number of errors (\texttt{maxnerr}) in evaluating
    the summary function for the simulated patterns, then instead
    of triggering a fatal error, the envelope limits will be set to \texttt{NA}.

\item \texttt{anova.mppm}:
  \begin{itemize}
  \item 
  Now handles Gibbs models,
  and performs the adjusted composite likelihood ratio test.
  \item 
  New argument \texttt{fine}.
  \item 
    Issues a warning when applied to random-effects models
    (models fitted using the argument \texttt{random}).
  \end{itemize}

\item \texttt{anyDuplicated.ppp}: Accelerated.
  
\item \texttt{append.psp}: arguments may be \texttt{NULL}.

  
\item \texttt{applynbd}:
  Now works for point patterns in three dimensions (class \texttt{"pp3"})
   and point patterns on a network (class \texttt{"lpp"}).

 \item \texttt{as.function.tess}:
    New argument \texttt{values} specifies the function values.

  \item \texttt{as.fv.kppm}:
    Improved arguments for empirical estimation of pair correlation function
    when the model was fitted with a non-default value of \texttt{method}.

  \item \texttt{as.im}: 
    \begin{itemize}
      \item Many methods for \texttt{as.im}
        now have argument \texttt{rule.pix} passed to \texttt{owin2mask}.
         This makes it possible to ensure that boundary pixels which partially
         intersect the window are included in the resulting pixel image,
         by setting \texttt{rule.pix="cover"}.
    \item 
      Many methods for \texttt{as.im}
      now have argument \texttt{rule.eps}.
    \end{itemize}

  \item \texttt{as.im.distfun}:
  New argument \texttt{approx} specifies the choice of algorithm.

  \item \texttt{as.im.tess}:
    \begin{itemize}
    \item
      New argument \texttt{rule.tile} specifies how to determine,
      for each pixel, the tile of the tessellation that covers the pixel.
    \item 
      New argument \texttt{values}.
    \end{itemize}

  \item \texttt{as.im.function}:
    \begin{itemize}
    \item   New argument \texttt{strict}.
    \item   New argument \texttt{stringsAsFactors}.
    \item 
   The formal default value of \texttt{stringsAsFactors}
   has been changed to \texttt{NULL}
   to conform to changes in R. (The actual default value is \texttt{TRUE}
   for \texttt{R < 4.1.0} and \texttt{FALSE} for \texttt{R >= 4.1.0}).
    \end{itemize}


  \item \texttt{as.im.leverage.ppm}:
  New argument \texttt{what}.

  \item \texttt{as.im.nnfun}:
  New argument \texttt{approx} chooses between a fast, approximate algorithm
  and a slow, exact algorithm.

  \item \texttt{as.im.smoothfun}:
  New argument \texttt{approx} chooses between a fast, approximate algorithm
  and a slow, exact algorithm.

\item \texttt{as.layered}:
    Default method now handles a (vanilla) list of spatial objects.

\item \texttt{as.layered.ppp}:
  Now handles rejected points in \texttt{attr(x, "rejects")} and 
  retrieves them as a layer.

\item \texttt{as.linfun.lintess}:
\begin{itemize}
\item New argument \texttt{values} specifies the function value for each tile.
\item The default \texttt{values} are the marks, if present.
\item New argument \texttt{navalue}.
\item Computation accelerated.
\end{itemize}

\item \texttt{as.linim.default}:
  \begin{itemize}
  \item 
   New arguments \texttt{delta} and \texttt{nd} control spacing of sample points
   in internal data.
 \item  New argument \texttt{rule.eps} passed to \texttt{as.mask}.
  \end{itemize}

\item \texttt{as.linim.linfun}:
  \begin{itemize}
 \item  New argument \texttt{rule.eps} passed to \texttt{as.mask}.
  \end{itemize}

 \item \texttt{as.linnet.linnet}:
   New argument \texttt{maxsize}.
   
  \item \texttt{as.linnet.psp}:
    \begin{itemize}
    \item New arguments \texttt{chop} and \texttt{fuse}.
    \item 
      If the line segment pattern has marks, then the resulting linear network
      also carries these marks in the \verb!$lines! component.
    \item Computation accelerated.
    \item The resulting network has attribute \texttt{"camefrom"} 
      indicating the provenance of each line segment in the network.
    \end{itemize}

    
  \item \texttt{as.lpp}: accepts more data formats:
    \begin{itemize}
    \item 
      Now handles the case where coordinates
      \texttt{seg} and \texttt{tp} are given
      but \texttt{x} and \texttt{y} are missing.
    \item Now handles the case where \texttt{x} is a data frame
      with columns named \texttt{x,y,seg,tp} or 
      \texttt{x,y} or \texttt{seg,tp}.
    \end{itemize}

  \item \texttt{as.mask:}
    New argument \texttt{rule.eps} specifies what to do when the
    desired pixel size is not a divisor of the frame size.

  \item \texttt{as.owin.default}:
  \begin{itemize}
  \item Now refuses to convert a \code{box3} to a two-dimensional window.
  \item Now accepts a structure with entries named
    \code{xmin},\code{xmax}, \code{ymin}, \code{ymax} in any order.
    This handles objects of class \code{bbox} in the \pkg{sf} package.
  \item Now detects objects of class \code{SpatialPolygons} and issues a
    more helpful error message.
  \end{itemize}

  \item \texttt{as.owin.data.frame}:
    New argument \texttt{step}

  \item \texttt{as.polygonal}:
    \begin{itemize}
    \item 
      Can now repair errors in polygon data, if \texttt{repair=TRUE}.
    \item Accelerated when \texttt{w} is a pixel mask.
    \end{itemize}
    
  \item \texttt{as.psp}: now permits a data frame of marks
    to have only one column, instead of coercing it to a vector.
    
  \item \texttt{as.rectangle}: accelerated in many cases.
    
  \item \texttt{as.solist}:
    The argument \texttt{x} can now be a spatial object;
    \texttt{as.solist(cells)} is the same as \texttt{solist(cells)}.

%%B
 \item \texttt{bdist.pixels}:
   Accelerated for polygonal windows. New argument \texttt{method}.

 \item \texttt{bdist.points}:
   Accelerated for polygonal windows. 

 \item \texttt{beachcolours}:
   \begin{itemize}
   \item  Improved positioning of the yellow colour band.
   \item  If \texttt{sealevel} lies outside \texttt{srange}, 
     then \texttt{srange} will be extended
     to include it (without a warning).
   \end{itemize}
   
 \item \texttt{beachcolourmap}:
   Improved positioning of the yellow colour band.
   
  \item \texttt{bilinearform}: This function has been moved
    to the sub-package \texttt{spatstat.sparse}.
    
 \item \texttt{bind.fv}:
   \begin{itemize}
   \item Additional arguments may be functions in the R language.
   \item New argument \texttt{clip}.
   \end{itemize}


 \item \texttt{blur}:
   New argument \texttt{kernel}.
   
 \item \texttt{bw.abram}:
   \begin{itemize}
   \item
     This function is now generic, with a method for class \texttt{ppp}.
   \item 
     Default method added.
   \item 
     New argument \texttt{smoother} determines 
     how the pilot estimate is computed.
   \item 
     Formal arguments rearranged. 
   \end{itemize}

 \item \texttt{bw.diggle}, \texttt{bw.ppl}, \texttt{bw.relrisk}, 
   \texttt{bw.smoothppp}:
   \begin{itemize}
   \item 
    These functions now extract and store the name of the unit of length
    from the point pattern dataset. When the bandwidth selection criterion
    is plotted, the name of the unit of length is shown on the x-axis.
  \item 
    A warning is issued if the optimal value of the cross-validation criterion
    occurs at an endpoint of the search interval.
    New argument \texttt{warn}.
   \end{itemize}
   
 \item \texttt{bw.ppl}:
   \begin{itemize}
   \item 
  New argument \texttt{varcov1} for anisotropic bandwidth selection.
   \item 
   New arguments \texttt{weights} and \texttt{sigma}.
 \item New argument \texttt{shortcut} allows faster computation.
 \item Argument \texttt{shortcut} now defaults to \texttt{TRUE}.
 \item Additional arguments \verb!...! are now passed to \texttt{density.ppp}.
   \end{itemize}

 \item \texttt{bw.relrisk}:
   This function is now generic, with methods for
   class \texttt{"ppp"} and \texttt{"lpp"}.
   
 \item \texttt{bw.relrisk.lpp}:
    When \texttt{method="likelihood"}, the cross-validation criterion
    is now defined as the \underline{\emph{negative}} likelihood. This is consistent with
    \texttt{bw.relrisk.ppp}, and ensures that the optimum bandwidth is always
    found by minimising the cross-validation criterion.
   
    
  \item \texttt{bw.relrisk.ppp}:
    Additional arguments \texttt{...} are now passed to \texttt{density.ppp}.
    
  \item \texttt{bw.scott}: 
    \begin{itemize}
    \item 
    the two bandwidth values in the result
    now have names \texttt{sigma.x} and \texttt{sigma.y}.
  \item Now handles point patterns of any dimension.
  \item New arguments \texttt{isotropic} and \texttt{d}.
    \end{itemize}

  \item  \texttt{bw.smoothppp}:
    \begin{itemize}
    \item New arguments \texttt{train} and \texttt{test} for cross-validation.
    \item New argument \texttt{varcov1} for anisotropic bandwidth selection.
    \end{itemize}

  \item \texttt{bw.stoyan}: 
    \begin{itemize}
    \item 
    The rule has been modified so that, 
    if the pattern is empty,
    it is now treated as if it contained 1 point,
    so that a finite bandwidth value is returned.
    \item New argument \texttt{extrapolate} supports a modification
      of Stoyan's rule.
  \end{itemize}    
  
  %% C
    
 \item \texttt{cbind.fv}:
   \begin{itemize}
   \item Additional arguments may be functions in the R language.
   \end{itemize}

  \item \texttt{cbind.hyperframe}:
    \begin{itemize}
    \item 
    The result now retains the \texttt{row.names}
    of the original arguments.
  \item 
    \end{itemize}
    
 \item \texttt{cdf.test}:
   \begin{itemize}
   \item    Calculations are more robust against numerical rounding effects.
   \item The methods for classes \texttt{ppp}, \texttt{ppm}, \texttt{lpp}, 
     \texttt{lppm}, \texttt{slrm} have a new argument \texttt{interpolate}.
   \item Monte Carlo test runs much faster.
   \item  More jittering is applied when \texttt{jitter=TRUE}.
    Warnings about tied values should not occur any more.
   \end{itemize}

 \item \texttt{cdf.test.ppm}:
   \begin{itemize}
   \item 
     Recognises argument \texttt{rule.eps} passed to \texttt{as.mask}.
   \end{itemize}
 
 \item \texttt{cdf.test.mppm}:
   \begin{itemize}
   \item     Now handles Gibbs models.
   \item     Now recognises \texttt{covariate="x"} or \texttt{"y"}.
   \end{itemize}
   
 \item \texttt{circdensity}:
   Improved output of \texttt{print} method.
    
 \item \texttt{clarkevans}:
    The argument \texttt{correction="all"} is now recognised: it selects
    all the available options. [This is also the default.]

 \item \texttt{clarkevans.test}:
   \begin{itemize}
   \item 
    The asymptotic test is now available for any choice of edge correction.
  \item 
    New argument \texttt{method} determines whether to use the asymptotic test
    or Monte Carlo test. The default has changed to
    \texttt{method="asymptotic"}.
  \item 
    Default edge correction has changed, to avoid bias.
  \end{itemize}
  
  \item \texttt{clickpoly}:
    \begin{itemize}
    \item     The polygon is now drawn progressively as the user clicks new vertices.
    \item     Allows user-selected locations of vertices to be snapped (rounded)
    to the nearest grid points. New arguments \texttt{snap.step} and 
    \texttt{snap.origin}.
    \end{itemize}



 \item \texttt{closepairs.ppp}:
   New argument \code{periodic}.
   
 \item \texttt{closepairs.ppp}, \texttt{closepairs.pp3}:
   \begin{itemize}
   \item New arguments \texttt{distinct} and \texttt{neat} allow more options.
   \item Argument \texttt{ordered} has been replaced by \texttt{twice}
    (but \texttt{ordered} is still accepted, with a warning).
  \item  
    Performance improved (computation time and memory requirements reduced.)
    This should improve the performance of many functions in \texttt{spatstat}.
   \end{itemize}
   
 \item \texttt{closepairs.pp3}:   
   Argument \texttt{what} can take the value \texttt{"ijd"}
   
 \item \texttt{clusterset}:
   Improved behaviour.

 \item \texttt{clusterfit}:
   \begin{itemize}
   \item 
   New argument \texttt{algorithm} specifies the choice 
   of optimisation algorithm.
    \item 
    Changed precedence rule for handling the algorithm parameters
    in the minimum contrast algorithm. Individually-named arguments
    \texttt{q,p,rmax,rmin} now take precedence over entries
    with the same names in the list \texttt{ctrl}.
  \item New argument \texttt{verbose}.
  \end{itemize}

 \item \texttt{clusterstrength}: 
   Now accepts an object of class \texttt{"clustermodel"}.

 \item \texttt{colourmap}:
  \begin{itemize}
  \item New arguments \texttt{compress}, \texttt{decompress} for nonlinear colour maps.
  \item 
    argument \texttt{col} can have length 1,
    representing a trivial colour map in which all data values are
    mapped to the same colour.
  \item 
    New arguments \texttt{compress}, \texttt{decompress}
    for nonlinear colour maps.
  \end{itemize}
  
\item \texttt{collapse.fv}:
  \begin{itemize}
  \item 
   This is now treated as a method for the \texttt{nlme} 
   generic \texttt{collapse}.
   Its syntax has been adjusted slightly.
 \item Recognises the abbreviations used by \texttt{fvnames()}.
  \end{itemize}

\item \texttt{connected.im}:
    Now handles a logical-valued image properly.
    Arguments \texttt{...} now determine pixel resolution.
    
\item \texttt{connected.owin}:
  \begin{itemize}
  \item New argument \texttt{polygonal} allows calculation of 
    connected components using polygonal geometry instead of pixel-based
    algorithm.
  \item Arguments \texttt{...} now determine pixel resolution.
  \end{itemize}



  \item \texttt{contour.im}:
    \begin{itemize}
    \item 
      New argument \texttt{col} specifies the colour of the contour lines.
      If \texttt{col} is a colour map, then the contours are drawn 
      in different colours.
    \item New argument \texttt{log} specifies whether the contour lines
    should be equally spaced on a logarithmic scale.
    \end{itemize}


  \item \texttt{convolve.im}: the name of the unit of length is preserved.
   
    
  \item \texttt{cor.im}, \texttt{cov.im}:
    Default changed to \texttt{use="complete.obs"}.
    
  \item \texttt{crossdist.lpp}:
    \begin{itemize}
    \item 
      Now handles much larger networks, using the sparse representation
      of the network.
    \item 
      New argument \texttt{check}.
    \end{itemize}

 \item \texttt{crossing.psp}:
    New argument \texttt{details} gives more information about the intersections
    between the segments.

  \item \texttt{crosspairs.ppp}:   
    \begin{itemize}
    \item New argument \texttt{periodic} specifies whether 
      to use periodic (toroidal) distances. 
    \item New arguments \texttt{iX}, \texttt{iY} make it possible to eliminate pairs
    in which the two points are identical.
    \end{itemize}

 \item \texttt{crosspairs.pp3}:   
   Argument \texttt{what} can take the value \texttt{"ijd"}

 \item \texttt{cut.ppp}:
    Argument \texttt{z} can be \texttt{"x"} or \texttt{"y"}
    indicating one of the spatial coordinates.    
    
%%D
    
  \item \texttt{dclf.test, mad.test, dclf.progress, mad.progress,} 
   \texttt{dclf.sigtrace, mad.sigtrace}, 
   \texttt{dg.progress, dg.sigtrace}:
   \begin{itemize}
   \item 
     New argument \texttt{clamp} determines the test statistic 
     for one-sided tests.
   \item 
     New argument \texttt{rmin} determines the left endpoint
     of the test interval.    
   \item 
     New argument \texttt{leaveout} specifies how to calculate
     discrepancy between observed and simulated function values.
   \item
     New argument \texttt{scale} allows summary function values to be rescaled
     before the comparison is performed.
   \item
     New argument \texttt{interpolate} supports interpolation of $p$-value.
   \item Function values which are infinite, \texttt{NaN} or \texttt{NA}
     are now ignored in the calculation (with a warning) instead of causing
     an error. Warning messages are more detailed.
   \end{itemize}
 

 \item \texttt{default.rmhcontrol, default.rmhexpand}:
   New argument \texttt{w}.

 \item \texttt{default.symbolmap.ppp}:
   \begin{itemize}
   \item For a multitype point pattern, \texttt{cols} can be 
     a \texttt{function(n)} 
   \item New argument \texttt{scramble.cols}
   \item 
   Argument \texttt{marktransform} renamed \texttt{transform} for consistency.
   \end{itemize}
   
 \item \texttt{densityBC}:
   \begin{itemize}
   \item accelerated
   \item new argument \texttt{xout}
   \end{itemize}
   
 \item \texttt{densityfun.ppp}:
   The resulting function can now handle query points which lie
    outside the window of the original data,
    and has argument \texttt{drop=TRUE} which specifies how to handle them.
   
    
  \item \texttt{densityEqualSplit}:
    New arguments \texttt{at} and \texttt{leaveoneout}
    for consistency with other functions.

 \item \texttt{densityHeat}: 
   \begin{itemize}
   \item    default behaviour has changed slightly.
   \item new argument \texttt{finespacing}.
   \end{itemize}

 \item \texttt{density.lpp}:
   \begin{itemize}
   \item 
     Argument \texttt{weights} can be logical valued.
   \item 
    Argument \texttt{sigma} can now be a function in the R language,
    assumed to provide a bandwidth selection rule. This function
    will be applied to the point pattern \texttt{x} to compute the bandwidth.
  \item 
    Argument \texttt{sigma=NULL} 
    is now accepted. The default value is one-eighth
    of the length of the shortest side of the bounding box of \texttt{x}.
   \item
    New fast algorithm (up to 1000 times faster) for the default case
    where \texttt{kernel="gaussian"} and \texttt{continuous=TRUE}.
    Generously contributed by Greg McSwiggan.
  \item Fast algorithm has been further accelerated.
  \item Further accelerated when the point pattern contains duplicated points.
   \item 
     New argument \texttt{kernel} specifies the smoothing kernel.
     Any of the standard one-dimensional smoothing kernels can be used.
   \item 
     Now supports both the `equal-split continuous' and 
     `equal-split discontinuous' smoothers. New argument \texttt{continuous} 
     determines the choice of smoother.
   \item 
     New arguments \texttt{weights} and \texttt{old}.
   \item New argument \texttt{distance} offers a choice of different
     kernel methods.
   \item Infinite bandwidth (\texttt{sigma=Inf}) is now permitted,
     and results in a density estimate that is constant over all locations.
   \end{itemize}
   
 \item \texttt{density.ppp}:
   \begin{itemize}
   \item Now accepts argument \texttt{rule.pix} passed to \texttt{owin2mask}.
   \item Argument \texttt{weights} can be logical-valued.
   \item A non-Gaussian kernel can now be specified
   using the argument \texttt{kernel}.
   \item Standard error calculation is now available with any smoothing kernel.
   \item The interpretation of \texttt{weights} in the calculation of
     standard error has changed. New argument \texttt{wtype}
     controls this interpretation.
 \item Argument \texttt{weights} can now be a pixel image.
 \item Infinite bandwidth \texttt{sigma=Inf} is supported.
   \item
     Accelerated by about 30\% when \texttt{at="pixels"}.
   \item Accelerated by about 15\%
     in the case where \texttt{at="points"}
     and \texttt{kernel="gaussian"}.
  \item 
     Accelerated in the cases where weights are given or \texttt{diggle=TRUE}.
   \item New argument \texttt{verbose}.
   \end{itemize}
   
   
 \item \texttt{densityQuick.lpp}:
   Argument \texttt{X} changed to \texttt{x} for consistency.

 \item \texttt{density.psp}:
   \begin{itemize}
   \item Now accepts argument \texttt{rule.pix} passed to \texttt{owin2mask}.
   \item New argument \texttt{method}.
   \item Accelerated by 1 to 2 orders of magnitude.
   \end{itemize}

 \item \texttt{density.splitppp}: New argument \texttt{weights}.
   
 \item \texttt{dfbetas.ppm}:
   \begin{itemize}
   \item 
    For Gibbs models, memory usage has been dramatically reduced, 
    so the code can handle larger datasets and finer quadrature schemes.
  \item 
    Increased the default resolution of the pixel images.
    Spatial resolution can now be controlled by the arguments 
    \code{dimyx}, \code{eps}.
    \item 
     Recognises argument \texttt{rule.eps} passed to \texttt{as.mask}.
     \end{itemize}

     
   \item diagnostic functions:
     \begin{itemize}
     \item The following functions have new formal argument \texttt{rmax}:
       \begin{quote}
         \texttt{Gcom}, \texttt{Kcom}, \texttt{psstA}, \texttt{psstG}, \texttt{psst}
       \end{quote}
     \item The following functions accept argument \texttt{rmax}:
       \begin{quote}
         \texttt{Gres}, \texttt{Kres}
       \end{quote}
     \item The following functions accept \texttt{correction="all"}:
       \begin{quote}
         \texttt{Gcom}, \texttt{Gres}, \texttt{Kcom}, \texttt{Kres}
       \end{quote}

     \end{itemize}
  \item \texttt{diagnose.ppm}:
    \begin{itemize}
    \item This is now a method for the generic \texttt{diagnose}.
    \item 
    Infinite values of \texttt{rbord} are now ignored and treated as zero.
    This ensures that \texttt{diagnose.ppm} has a sensible default
    when the fitted model has infinite reach.
  \item Accelerated, when \texttt{type="inverse"}, for models
    without a hard core.
    \end{itemize}
  
  \item \texttt{diagnose.ppm, plot.diagppm}:
    \begin{itemize}
    \item 
   New arguments \texttt{col.neg, col.smooth} control the colour maps.
    \item Accelerated, when \texttt{type="inverse"}, for models without
   a hard core.
    \end{itemize}

  \item \texttt{diameter.owin}: accelerated when the window is a rectangle.
    
  \item \texttt{dilation.ppp}:
    Improved geometrical accuracy.
    Now accepts arguments to control resolution of polygonal approximation.

    
  \item \texttt{dirichletEdges}:
    New argument \texttt{clip}.

     \item \texttt{discretise}:
       \begin{itemize}
       \item 
           New argument \texttt{move.points}
           determines whether the point coordinates
           are also discretised.
         \item New argument \texttt{rule.eps}
       \end{itemize}


 \item \texttt{disc}:
    New argument \texttt{type} allows the user to specify an inscribed polygon
    or a circumscribed polygon.
       
 \item \texttt{discs}:
   \begin{itemize}
   \item     Now accepts a single numeric value for \texttt{radii}.
   \item New argument \texttt{npoly}.
   \item Accelerated in some cases. 
   \end{itemize}

 \item \texttt{distcdf}:
   \begin{itemize}
   \item    Arguments which are \texttt{NULL} will be treated as missing.
   \item New argument \texttt{savedenom}.
   \end{itemize}


   
  \item \texttt{distfun}:
    \begin{itemize}
    \item 
      When the user calls a distance function 
      that was created by \texttt{distfun},
      the user may now give a \texttt{ppp} or \texttt{lpp}
      object for the argument \texttt{x},
      instead of giving two coordinate vectors \texttt{x} and \texttt{y}.
    \item
      New argument \texttt{rule.eps}
    \end{itemize}

 \item \texttt{distfun.lpp}:
   \begin{itemize}
   \item    New argument \texttt{k} allows computation of $k$-th nearest point.
   \item    Computation accelerated.
   \end{itemize}
    
 \item \texttt{distfun.owin}:
   New argument \texttt{signed}.
   
 \item \texttt{distmap.owin}:
   \begin{itemize}
   \item    New argument \texttt{signed}.
   \item New argument \texttt{connect}.
   \item 
    Behaviour has been altered so that, when \texttt{X} is a binary mask, the results of
    \texttt{distmap(X, invert=TRUE)} and \texttt{distmap(complement.owin(X))} are identical.
    This affects a few pixels close to the edge of the frame.
  \end{itemize}

\item \texttt{distmap.ppp}:
  \begin{itemize}
  \item 
    New option \texttt{squared=TRUE} returns the squared distances,
    reducing computation time.
  \item 
    New option \texttt{extras=FALSE} avoids returning additional attributes,
    reducing computation time.
  \item    New argument \texttt{clip}.
  \end{itemize}



 \item \texttt{distmap.psp}:
   New arguments \texttt{extras} and \texttt{clip}.
   
    \item \texttt{dppm}:
    Changed precedence rule for handling the algorithm parameters
    in the minimum contrast algorithm. Individually-named arguments
    \texttt{q,p,rmax,rmin} now take precedence over entries
    with the same names in the list \texttt{ctrl}.
    
    
  \item \texttt{duplicated.ppp}: accelerated.

%%E
    
  \item \texttt{edge.Trans}:
    New argument \texttt{gW} for efficiency.

  \item \texttt{edge.Ripley}:
    \begin{itemize}
    \item New argument \texttt{bdistX} for efficiency.
    \item Responds more quickly to user interrupt signal.
    \end{itemize}
    
  \item \texttt{eem}:
    The function \texttt{eem} is now generic, with methods for 
    \texttt{ppm} and \texttt{slrm}.
    The function previously named \texttt{eem} is now called \texttt{eem.ppm}.

  \item \texttt{effectfun}:
    \begin{itemize}
    \item Improved defaults for a recursive partition model 
      (class \texttt{"rppm"}).
      The user only needs to provide values for those covariates which
      are used in the decision tree. If the entire tree involves only one
      variable, then \texttt{covname} is not needed.
    \item If a spatial covariate is constant, its value does not need to
      be provided in the call to \texttt{effectfun}.
    \item 
    Now works for \texttt{ppm}, \texttt{kppm}, 
    \texttt{lppm}, \texttt{dppm}, \texttt{rppm} and \texttt{profilepl} objects.
    \item New argument \texttt{nvalues}.
    \item Standard error calculation (\texttt{se.fit=TRUE}) now works 
      for models fitted with \texttt{use.gam=TRUE}.
    \end{itemize}
    
  \item \texttt{Emark}:
    The result now has an attribute \texttt{smooth.args}
    containing the smoothing parameters used.

    
 \item \texttt{envelope}:
   \begin{itemize}
   \item 
     Argument \texttt{simulate} can be a point process model of class
    \texttt{"ppm"}, \texttt{"kppm"}, \texttt{"dppm"}, \texttt{"slrm"}, 
    \texttt{"clusterprocess"} or \texttt{"detpointprocfamily"}.
 \item 
   New argument \texttt{theoryfun} can be used to provide the theoretical value
   of the summary function.
   \item 
     All methods for \texttt{envelope} now accept a summary function 
    in which the function argument is not named \texttt{r}.
    This includes functions such as \texttt{transect.im} and \texttt{roc}.
   \item 
     New argument \texttt{clamp} gives greater control
     over one-sided envelopes.
   \item  New argument \texttt{funargs}
   \item 
     New argument \texttt{scale} allows global envelopes to have 
     width proportional to a specified function of $r$,
     rather than constant width.
   \item 
     New argument \texttt{funYargs} contains arguments to the summary function
     when applied to the data pattern only.
   \item 
     The argument \texttt{simulate} can now be a function
     (such as \texttt{rlabel}). The function will be applied repeatedly
     to the original data pattern.
  \item \texttt{rejectNA} and \texttt{silent}.
   \end{itemize}

 \item \texttt{envelope.lpp}, \texttt{envelope.lppm}:
   \begin{itemize}
   \item 
     New argument \texttt{theoryfun} can be used to provide the theoretical value
     of the summary function.

   \item 
    New arguments \texttt{fix.n} and \texttt{fix.marks}
    allow envelopes to be computed
    using simulations conditional on the observed number of points.   
  \item New arguments \texttt{maxnerr}, \texttt{rejectNA} and \texttt{silent}.
   \end{itemize}

 \item \texttt{envelope.pp3}:
   \begin{itemize}
   \item 
   Marked point patterns are accepted.
 \item 
   New arguments \texttt{fix.n} and \texttt{fix.marks} determine whether the 
   simulated patterns have a fixed or random number of points.
   \end{itemize}

 \item \texttt{erosion.owin}:
   when \texttt{shrink.frame=TRUE} (the default), 
   the  frame of the resulting window
    is always the erosion of the original frame by distance \texttt{r},
    as promised in the help file.
    
 \item \texttt{eval.im}:  New argument \texttt{warn}.
   
 \item \texttt{eval.linim}:  New argument \texttt{warn}.
   
 \item \texttt{eval.fasp}: automatically generated labels have been improved.
   
 \item \texttt{ewcdf}: 
   \begin{itemize}
   \item 
     Argument \texttt{weights} can now be \texttt{NULL}.
   \item 
     New arguments \texttt{normalise} and \texttt{adjust}.
   \item 
     Computation accelerated.
   \item 
     The result does not inherit class \texttt{"ecdf"} if
     \texttt{normalise=FALSE}. 
  \end{itemize}
   
%%F
   
 \item \texttt{Fest}:
   \begin{itemize}
   \item New argument \texttt{rmax}.
   \item Additional checks for errors in input data.
   \end{itemize}



 \item \texttt{Finhom}:
   \begin{itemize}
   \item New argument \texttt{rmax}.
   \item 
     A warning is issued if bias is likely to occur because of
     undersmoothing.
   \item 
     New arguments \texttt{warn.bias} and \texttt{savelambda}.
   \end{itemize}
   
 \item \texttt{fastFindInterval}:
   New argument \texttt{left.open} controls whether intervals are
   left-open and right-closed, or left-closed and right-open.
   
 \item \texttt{fitted.lppm}:
  New argument \texttt{leaveoneout}
  allows leave-one-out computation of fitted value.
  
 \item \texttt{fitted.ppm}:
   \begin{itemize}
   \item   New option, \texttt{type="link"}.
   \item New argument \code{ignore.hardcore}.
   \end{itemize}

 \item \texttt{fitted.slrm}:
   \begin{itemize}
   \item
     Argument \texttt{leaveoneout} is no longer ignored when 
     \texttt{dataonly=FALSE};
     it now supports ``leave-one-pixel-out'' prediction.
   \item   New argument \texttt{type} allows calculation of fitted
     probabilities, intensities or link function values.
   \item 
      New arguments \texttt{dataonly} and \texttt{leaveoneout}
      allow calculation of fitted
      values at the data points only, 
      using leave-one-out calculation if desired.
   \end{itemize}

   
 \item \texttt{FmultiInhom}:  New argument \texttt{rmax}.

 \item \texttt{funxy}:
    \begin{itemize}
    \item 
    When the user calls a function that was created by \texttt{funxy},
    the user may now give a \texttt{ppp} or \texttt{lpp}
    object for the argument \texttt{x},
    instead of giving two coordinate vectors \texttt{x} and \texttt{y}.
  \item 
    Functions of class \texttt{"funxy"} can now be applied to
    quadrature schemes.
  \item 
    The result now has a \texttt{unitname}, inherited from the argument \texttt{W}.
  \end{itemize}


%%G
    
 \item \texttt{Gcross}:
   \begin{itemize}
   \item New argument \texttt{rmax}.
   \item    Function labels (shown on the plot legend) have been improved when 
   \texttt{i = j}.

   \end{itemize}

   
  \item \texttt{Geyer}:
   The saturation parameter \texttt{sat} can now be less than 1.
   
 \item \texttt{Ginhom}:
   \begin{itemize}
   \item 
     A warning is issued if bias is likely to occur because of
     undersmoothing.
   \item 
     New arguments \texttt{warn.bias} and \texttt{savelambda}.
   \end{itemize}
   
   
   \item \texttt{grow.rectangle}:
     New argument \texttt{fraction}.
%%H
   
     
   \item \texttt{harmonise.im}:
     \begin{itemize}
     \item Accelerated in the common case where all rasters are identical.
     \item  The result belongs to classes \texttt{solist} and \texttt{imlist}
     so that it can be plotted.

     \end{itemize}

     
 \item \texttt{Hest}:
   \begin{itemize}
   \item Argument \texttt{X} can now be a pixel image with logical values.
   \item New argument \texttt{W}. [Based on code by Kassel Hingee.]
   \item Additional checks for errors in input data.
   \end{itemize}
   
 \item \texttt{hist.im}: New argument \texttt{xname}.
   
 
 \item \texttt{hyperframe}: 
   \begin{itemize}
   \item 
     An object of class \texttt{Surv} from the \texttt{survival} package
     is now treated as a single column of data
     (mimicking the behaviour of \texttt{data.frame})
   \item 
   The formal default value of \texttt{stringsAsFactors}
   has been changed to \texttt{NULL}
   to conform to changes in R. (The actual default value is \texttt{TRUE}
   for \texttt{R < 4.1.0} and \texttt{FALSE} for \texttt{R >= 4.1.0}).
 \item     Removed slight inconsistencies in the internal format
    produced in different cases.
   \end{itemize}
   
%%I
 \item \texttt{identify.ppp}: 
   Automatically starts a new plot device if none is open.

   \item \texttt{identify.psp}: 
   \begin{itemize}
   \item New arguments \texttt{paint} and \texttt{paint.args}.
   \item Identified segments are highlighted.
   \item Automatically starts a new plot device if none is open.
   \item 
     Improved placement of labels.
   \item 
     Arguments can be passed to \texttt{text.default}
     to control the plotting of labels.
   \end{itemize}
   
 \item \texttt{idw}: Standard errors can now be calculated by
   setting \texttt{se=TRUE}.
   
  \item \texttt{imcov}: the name of the unit of length is preserved.

  \item \texttt{im.apply}: 
    \begin{itemize}
    \item Now handles vector-valued functions.
    \item Computation accelerated
    \item New argument \texttt{fun.handles.na}
    \item New argument \texttt{check}
    \item Improved algorithm avoids violating memory limits, 
      handles larger datasets. 
    \end{itemize}
    
 \item \texttt{influence.ppm}:
    For Gibbs models, memory usage has been dramatically reduced, 
    so the code can handle larger datasets and finer quadrature schemes.

 \item \texttt{integral.im}:
   \begin{itemize}
   \item New argument \texttt{weight} specifies a weight function for the integration.
   \item Accelerated in the case where \texttt{domain} is a tessellation.
   \end{itemize}
   
 \item \texttt{integral.linfun}:
   \begin{itemize}
   \item New argument \texttt{exact}. 
     If \texttt{exact=TRUE}, a more accurate algorithm is used.
   \item Argument \texttt{domain} can be a tessellation on a network
     (class \texttt{lintess}).
   \item New argument \texttt{weight} specifies a weight function for the integration.
   \item    New argument \texttt{delta} controls step length of
   approximation to integral.
 \item New argument \texttt{nd} controls approximate number of sample points
   used to calculate integral.
   \item    Argument \code{domain} can be a tessellation.
   \item Now handles complex-valued functions.
   \end{itemize}

 \item \texttt{integral.linim}:
   \begin{itemize}
   \item Argument \texttt{domain} can be a tessellation on a network
     (class \texttt{lintess}).
   \item New argument \texttt{weight} specifies a weight function for the integration.
   \item Argument \code{domain} can be a tessellation.
   \item Now handles complex-valued functions.
   \end{itemize}

 \item \texttt{integral.msr}:
   New argument \texttt{weight} specifies a weight (integrand) for the integration.
   
 \item \texttt{integral.ssf}:
   Argument \code{domain} can be a tessellation.

   
 \item \texttt{intensity.ppp}: 
   Argument \texttt{weights} can be logical-valued.

\item \texttt{intensity.ppm}:
  \begin{itemize}
  \item    Intensity approximation is now implemented for
   area-interaction model, and Geyer saturation model.
 \item Can now calculate the Coeurjolly-Lavancier DPP approximation of intensity.
    [Code kindly contributed by Frederic Lavancier]
  \item New argument \texttt{approx} specifies the choice of approximation.
  \end{itemize}


\item \texttt{interp.im}:
  New argument \texttt{bilinear}.

\item \texttt{intersect.lintess}:
  Can also compute the intersection between a two-dimensional tessellation
  and a linear network (yielding a tessellation on the network).

\item \texttt{intersect.owin}:
  New argument \texttt{rescue}.
  
\item \texttt{intersect.tess}:
  \begin{itemize}
  \item Now handles marks of any kind (vector, list, data frame or hyperframe).
  \item   New argument \texttt{keepempty}.
  \end{itemize}



\item \texttt{invoke.symbolmap}: new argument \texttt{angleref}.
 
\item \texttt{iplot}, \texttt{iplot.ppp}, 
  \texttt{iplot.layered}, \texttt{iplot.linnet}, \texttt{iplot.default}:
    These interactive plotting functions have been removed from 
    \pkg{spatstat} into a new package \pkg{spatstat.gui}.

 \item \texttt{ippm}:
   \begin{itemize}
   \item Accelerated.
   \item 
   The internal format of the result has been extended slightly.
   \item Improved defaults for numerical algorithm parameters.
   \end{itemize}
   
   
 \item \texttt{istat}:
    This interactive analysis function has been removed from \pkg{spatstat}
    into a new package \pkg{spatstat.gui}.
    
%%J

 \item \texttt{Jcross}: 
   Function labels (shown on the plot legend) have been improved when 
   \texttt{i = j}.
   
 \item \texttt{Jfox}: new argument \texttt{warn.trim}.
   
 \item \texttt{Jinhom}:
   \begin{itemize}
   \item 
     A warning is issued if bias is likely to occur because of
     undersmoothing.
   \item 
     New arguments \texttt{warn.bias} and \texttt{savelambda}.
   \end{itemize}
   
   
%%K

 \item \texttt{Kcross}: 
   \begin{itemize}
   \item 
     Function labels (shown on the plot legend) have been improved when 
     \texttt{i = j}.
   \item 
     Now accepts  the option \texttt{correction="periodic"}
     to compute the periodic (toroidal) edge correction estimate.
   \end{itemize}

 \item \texttt{Kcross.inhom}, \texttt{Kdot.inhom}, \texttt{Kmulti.inhom}:
   \begin{itemize}
   \item  
     Interpretation of arguments \texttt{lambdaI}, \texttt{lambdaJ}, 
     \texttt{lambdaX}, \texttt{lambdadot}
     has changed when they are fitted point process models. If the model is
     a multitype point process then it is assumed to be a model for the 
     entire point pattern \texttt{X}, 
     while if the model is an unmarked point process
     then it is assumed to be a model for the relevant subset of the data.

   \item 
    These functions now allow intensity values to be given by
    a fitted point process model.
  \item 
    New arguments \texttt{update}, \texttt{leaveoneout}, \texttt{lambdaX}.
  \item 
    Leave-one-out calculation is now implemented
    when \texttt{lambbdaX} is a fitted model of class \texttt{"dppm"}.
   \end{itemize}

   
 \item \texttt{Kdot}:
   Now accepts  the option \texttt{correction="periodic"}
   to compute the periodic (toroidal) edge correction estimate.

 \item \texttt{Kest}
   \begin{itemize}
   \item 
    Accelerated computation (for translation and rigid corrections)
    when window is an irregular shape.
  \item 
    Calculation of isotropic edge correction for polygonal windows
    has changed slightly. Results are believed to be more accurate.
    Computation has been accelerated by about 20 percent in typical cases.
  \item 
    Now accepts  the option \texttt{correction="periodic"}
    to compute the periodic (toroidal) edge correction estimate.
   \end{itemize}

\item \texttt{Kest.fft}:
   Now has \verb!...! arguments allowing control of spatial resolution.

\item \texttt{Kinhom}:
   \begin{itemize}
   \item 
   New argument \texttt{ratio}.
 \item 
   Stops gracefully if \texttt{lambda} contains any zero values.
 \item 
   Leave-one-out calculation is implemented when \texttt{lambda}
   is a fitted model of class \texttt{"dppm"}.

   \end{itemize}

\item \texttt{Kmulti}:
  Now accepts the option \texttt{correction="periodic"}
  to compute the periodic (toroidal) edge correction estimate.

\item \texttt{kernel.moment}:
  \begin{itemize}
  \item    New arguments \texttt{mean} and \texttt{sd}.
  \item Computation accelerated for \texttt{kernel='cosine'} or 
    \texttt{'optcosine'}.
  \item All cases are now computed using analytic expressions, for 
    \texttt{m=0,1,2}.
  \end{itemize}

 \item \texttt{kppm}:
   \begin{itemize}
   \item New option: \texttt{method="waag"} fits the model by maximising
    Waagepetersen's (2007) second order composite likelihood
   \item 
     The code for fitting log-Gaussian Cox process models 
     (\texttt{clusters="LGCP"})
    has been re-implemented without using the package \pkg{RandomFields}.
    The current code supports the \texttt{"exponential"}, 
    \texttt{"gauss"}, \texttt{"stable"},
    \texttt{"gencauchy"} and \texttt{"matern"} covariance models.
   \item 
    Computation accelerated when \texttt{method="palm"} or 
    \texttt{method="clik2"}.
    [Kindly contributed by Bethany Macdonald.]
   \item 
     New argument \texttt{trajectory} specifies whether to save the history
     of function evaluations performed by the optimization algorithm.
   \item 
     New argument \texttt{penalised} supports penalised model-fitting 
     with a penalty against extremely large or small values 
     of the cluster scale. 
   \item 
     New arguments \texttt{ppm.improve.type} and \texttt{ppm.improve.args}.
   \item 
     The first order trend is fitted using a regularized fitting algorithm
     when \texttt{ppm.improve.type="enet"}.
   \item 
     New default settings ensure greater numerical stability of the
     optimization algorithm against the effects of the scale of the
     spatial coordinates.  New argument \texttt{stabilize} specifies whether
     the optimization algorithm should be numerically stabilized.
   \item 
     Fitting a model with \texttt{clusters="LGCP"} no longer requires the
     package \pkg{RandomFields} to be loaded explicitly.
   \item
     New argument \texttt{algorithm} specifies the choice 
     of optimisation algorithm.
     \item 
       Left hand side of formula can now involve entries 
       in the list \texttt{data}.
     \item refuses to fit a log-Gaussian Cox model with anisotropic covariance.
     \item 
    A warning about infinite values of the summary function 
    no longer occurs when the default settings are used.
    Also affects \texttt{mincontrast}, 
    \texttt{cauchy.estpcf}, \texttt{lgcp.estpcf}, \texttt{matclust.estpcf},
    \texttt{thomas.estpcf}, \texttt{vargamma.estpcf}.
  \item 
    Changed precedence rule for handling the algorithm parameters
    in the minimum contrast algorithm. Individually-named arguments
    \texttt{q,p,rmax,rmin} now take precedence over entries
    with the same names in the list \texttt{ctrl}.
    \item
    Improved printed output.
    \item
    Improved numerical robustness.
  \end{itemize}
  
%%L
   
\item \texttt{latest.news}: 
  Now prints news documentation for the current major version, by default.
  New argument \texttt{major}.

  \item \texttt{layout.boxes}: Argument \code{aspect} can be 
    \code{NA} or \code{Inf} indicating that the aspect ratio
    of the boxes is unconstrained.
    
\item \texttt{Lcross}:
  Now accepts  the option \texttt{correction="periodic"}
  to compute the periodic (toroidal) edge correction estimate.
  
\item \texttt{Ldot}:
  Now accepts  the option \texttt{correction="periodic"}
  to compute the periodic (toroidal) edge correction estimate.
  
 \item \texttt{Lcross.inhom}, \texttt{Ldot.inhom}:
    These functions now allow intensity values to be given by
    a fitted point process model.
    New arguments \texttt{update}, \texttt{leaveoneout}, \texttt{lambdaX}.

 \item \texttt{lengths.psp}: 
   \begin{itemize}
   \item    New argument \texttt{squared}.
   \item This function will soon be Deprecated in favour of the
     new name \verb!lengths_psp!.
   \end{itemize}

   \item \texttt{Lest}, \texttt{Linhom}, \texttt{Ldot},
     \texttt{Lcross}, \texttt{Ldot.inhom}, \texttt{Lcross.inhom}:
     These summary functions now have explicit argument \texttt{"correction"}.

   \item \texttt{levelset}:
     \begin{itemize}
     \item This function is now generic and can be applied to pixel images
       or functions. 
     \item For some kinds of functions, the level set is calculated
       more accurately using analytic geometry and returned as a polygonal
       window. This includes
       \begin{itemize}
       \item Functions of class \texttt{"distfun"} created bt \texttt{distfun}
         where the level set is a dilation of the original object
       \item Functions of class \texttt{tessfun} created by
         \texttt{as.function.tess} where the level set is a union of tiles
         of the tessellation.
       \end{itemize}
     \end{itemize}
     
 \item \texttt{leverage.ppm}:
   \begin{itemize}
   \item 
    For Gibbs models, memory usage has been dramatically reduced, 
    so the code can handle larger datasets and finer quadrature schemes. 
  \item 
    Increased the default resolution of the pixel images.
    Spatial resolution can now be controlled by the arguments 
    \code{dimyx}, \code{eps}.
   \item 
     Recognises argument \texttt{rule.eps} passed to \texttt{as.mask}.
   \end{itemize}

 \item \texttt{leverage.ppm}, \texttt{influence.ppm}, \texttt{dfbetas.ppm}:
   \begin{itemize}
   \item These methods now work for models that were fitted by logistic
    composite likelihood (\texttt{method='logi'}).
  \item Computation has been vastly accelerated for models 
    with Geyer interaction
    fitted using isotropic or translation edge corrections.
  \item Faster computation in many cases.
  \item  Virtually all models and edge corrections are now supported,
    using a ``brute force'' algorithm. This can be slow in some cases.
   \end{itemize}
   
  \item \texttt{lgcp.estK}, \texttt{lgcp.estpcf}:
    This code for fitting log-Gaussian Cox process models 
    has been re-implemented without using the package \pkg{RandomFields}.
    The current code supports the \texttt{"exponential"}, 
    \texttt{"gauss"}, \texttt{"stable"},
    \texttt{"gencauchy"} and \texttt{"matern"} covariance models.

   

 \item \texttt{lineardisc}:
   \begin{itemize}
   \item New argument \texttt{add}.
   \item Default plotting behaviour has changed.
   \end{itemize}

 \item \texttt{linearK}, \texttt{linearpcf} and relatives: \\ 
   \begin{itemize}
     \item substantially accelerated.
     \item ratio calculations are now supported.
     \item new argument \texttt{ratio}.
     \end{itemize}
     
     
   \item \texttt{linearKEuclidInhom}, \texttt{linearpcfEuclidInhom}:
     Argument \texttt{lambda=NULL}
     is now interpreted to mean that the intensity
     should be estimated by kernel smoothing. A warning is issued that this
     is different from the previous behaviour.
     
 \item \texttt{linearKinhom}:
   new argument \texttt{normpower}.
   
 \item \texttt{linearKdot.inhom}, \texttt{linearpcfdot.inhom}:
   \begin{itemize}
   \item 
      When argument \texttt{lambdaI} or \texttt{lambdadot}
      is a point process model,
      the interpretation now depends on whether the model is multitype or
      unmarked.  A multitype point process model will be interpreted as
      providing the intensity for each possible type of point. An unmarked point
      process model will be interpreted as providing the intensity only for the
      relevant type of point (type \texttt{i} only, 
      or total intensity for all types of points).
   \item 
   Argument \texttt{lambdaI=NULL} or \texttt{lambdadot=NULL} 
   is now interpreted to mean
   that the intensity should be estimated by kernel smoothing.
   \end{itemize}
   
 \item \texttt{linearKcross.inhom}, \texttt{linearpcfcross.inhom}
   \begin{itemize}
   \item 
      When argument \texttt{lambdaI}, \texttt{lambdaJ} or \texttt{lambdadot}
      is a point process model,
      the interpretation now depends on whether the model is multitype or
      unmarked.  A multitype point process model will be interpreted as
      providing the intensity for each possible type of point. An unmarked point
      process model will be interpreted as providing the intensity only for the
      relevant type of point (type \texttt{i} only, type \texttt{j} only, 
      or total intensity for all types of points).
   \item 
   Argument \texttt{lambdaI=NULL} or \texttt{lambdaJ=NULL} 
   is now interpreted to mean
   that the intensity should be estimated by kernel smoothing.
 \end{itemize}

\item \texttt{linearKinhom}, \texttt{linearpcfinhom}:
   \begin{itemize}
   \item Argument \texttt{lambda=NULL}
     is now interpreted to mean that the intensity
     should be estimated by kernel smoothing. A warning is issued that this
     is different from the previous behaviour.
   \item Changed behaviour when \texttt{lambda} is a fitted model.
   \item New arguments \texttt{update} and \texttt{leaveoneout}.
   \end{itemize}
   
 \item \texttt{linearpcf}:
   new argument \texttt{normpower}.

 \item \texttt{linearpcfinhom}:
   New arguments \texttt{adjust.sigma}, \texttt{bw} and \texttt{adjust.bw}.

 \item \texttt{linearpcfcross.inhom}, \texttt{linearpcfdot.inhom}:
   New arguments \texttt{adjust.sigma}, \texttt{bw} and \texttt{adjust.bw}.

 \item \texttt{linearpcfEuclidInhom}:
   New arguments \texttt{adjust.sigma}, \texttt{bw} and \texttt{adjust.bw}.

 \item \texttt{linequad}:
   Argument \texttt{Y} can be a linear network.

 \item \texttt{linim}:
   \begin{itemize}
   \item The image \texttt{Z} is now automatically restricted to the network.
   \item New argument \texttt{restrict}.
   \end{itemize}
   
 \item \texttt{linnet}:
   \begin{itemize}
   \item
     The internal format of a \texttt{linnet} (linear network) object
    has been changed. Existing datasets of class \texttt{linnet} 
    are still supported. However, computation will be faster if they
    are converted to the new format. To convert a linnet object \texttt{L}
    to the new format, use \verb!L <- as.linnet(L)!.
   \item 
    If the argument \texttt{edges} is given, then this argument
    now determines the
    ordering of the sequence of line segments. For example, the \texttt{i}-th
    row of \texttt{edges} specifies the \texttt{i}-th line segment in 
    \texttt{as.psp(L)}.
  \item New argument \texttt{warn}.
  \item When argument \texttt{edges} is specified, the code now checks 
    whether any edges are duplicated.
   \end{itemize}

  \item \texttt{lintess}:
    \begin{itemize}
    \item Argument \texttt{df} can be missing or \texttt{NULL}, 
      resulting in a tesellation with only one tile.
    \item Tessellations can now have marks. New argument \texttt{marks}.
    \end{itemize}
  
  \item \texttt{localpcf}:
    New argument \texttt{rvalue}.
    
  \item \texttt{localpcfinhom}:
    \begin{itemize}
    \item New arguments \texttt{update}, \texttt{leaveoneout}, \texttt{rvalue}.
    \end{itemize}
    
  \item \texttt{logLik.ppm}:
    \begin{itemize}
    \item  New argument \texttt{absolute}.
    \item The warning about pseudolikelihood (`log likelihood not available')
    is given only once, and is not repeated in subsequent calls,
    within a spatstat session.
    \end{itemize}

 \item \texttt{logLik.mppm}: new argument \texttt{warn}.
   
 \item \texttt{lohboot}:
   \begin{itemize}
   \item 
     Algorithm has been corrected and extended
    thanks to Christophe Biscio and Rasmus Waagepetersen.
  \item
    New arguments \texttt{block}, \texttt{basicboot}, \texttt{Vcorrection}.
  \item 
    Accelerated when the window is a rectangle.
  \item 
    Now works for multitype $K$
    functions \texttt{Kcross}, \texttt{Kdot}, \texttt{Lcross}, \texttt{Ldot},
    \texttt{Kcross.inhom}, \texttt{Lcross.inhom}
  \item 
    Confidence bands for \texttt{Lest}, \texttt{Linhom},
    \texttt{Lcross}, \texttt{Ldot}, \texttt{Lcross.inhom} 
    are now computed differently.
    First a confidence band is computed for the corresponding $K$
    function \texttt{Kest}, \texttt{Kinhom}, \texttt{Kcross}, \texttt{Kdot},
    \texttt{Kcross.inhom} respectively. Then this is transformed 
    to a confidence band for the $L$ function by applying the 
    square root transformation.
   \end{itemize}

 \item \texttt{lpp}:
   \begin{itemize}
   \item 
    The internal format of an \texttt{lpp} object
    has been changed. Existing datasets of class \texttt{lpp} 
    are still supported. However, computation will be faster if they
    are converted to the new format. To convert an \texttt{lpp} 
    object \texttt{X} to the new format, use \verb!X <- as.lpp(X)!.
   \item
     \texttt{X} can be missing or \texttt{NULL}, 
     resulting in an empty point pattern.
   \item 
     Now handles the case where coordinates
     \texttt{seg} and \texttt{tp} are given
     but \texttt{x} and \texttt{y} are missing.
   \end{itemize}

 \item \texttt{lppm}:
   \begin{itemize}
   \item The model formula may involve the local coordinates
     \texttt{seg} and \texttt{tp}.
   \item Covariates can be objects of class \texttt{lintess}.
   \item New argument \texttt{random} controls placement of dummy points.
   \item    Computation accelerated.
   \end{itemize}

\item \texttt{lurking.lppm}:
  \begin{itemize}
  \item Argument \texttt{covariate} can be a \texttt{function(x,y)}
    or one of the strings \texttt{"x"} or \texttt{"y"}.
  \item When the covariate is a cartesian coordinate or a distance function,
    the unit of length is stated on the horizontal axis label of the plot.
  \end{itemize}
  
\item \texttt{lurking.ppm}:
  \begin{itemize}
  \item Argument \texttt{covariate} can be a \texttt{function(x,y)}
    or one of the strings \texttt{"x"} or \texttt{"y"}.
  \item When the covariate is a cartesian coordinate or a distance function,
    the unit of length is stated on the horizontal axis label of the plot.
  \item accelerated.
  \end{itemize}

\item \texttt{lurking.slrm}:
  \begin{itemize}
  \item Argument \texttt{covariate} can be a \texttt{function(x,y)}
    or one of the strings \texttt{"x"} or \texttt{"y"}.
  \item When the covariate is a cartesian coordinate or a distance function,
    the unit of length is stated on the horizontal axis label of the plot.
  \end{itemize}

\item \texttt{lut}:
  \begin{itemize}
  \item 
    argument \texttt{outputs} may have length 1, 
  representing a lookup table in which all data values are mapped
  to the same output value.
\item 
  New arguments \texttt{compress}, \texttt{decompress} for nonlinear
  lookup tables.
\end{itemize}
  
%%M
   
 \item \texttt{markconnect}:
   \begin{itemize}  
   \item 
    The result now has an attribute \texttt{smooth.args}
    containing the smoothing parameters used.
   \item 
     Accepts the argument \texttt{weights} 
     which is passed to \texttt{markcorr}.
   \end{itemize}

 \item \texttt{markcorr}:
   \begin{itemize}
   \item Argument \texttt{weights} can be logical-valued.
   \item 
    The result now has an attribute \texttt{smooth.args}
    containing the smoothing parameters used.
  \item 
    New argument \texttt{fadjust}.
   \item 
     New argument \texttt{weights} allows computation of the weighted version
     of the mark correlation function.
     Weights can be an expression
     to be evaluated, or a function, or a pixel image, or a numeric vector.
     (NOTE: interpretation of \texttt{weights} has changed in 
     \texttt{spatstat.explore} version \texttt{3.6-1})
   \item 
     Now allows negative mark values, when \texttt{normalise=FALSE}.
   \end{itemize}

\item \texttt{markcrosscorr}:
  \begin{itemize}
   \item Argument \texttt{weights} can be logical-valued.
  \item New argument \texttt{weights}.
  \item Now allows negative mark values, when \texttt{normalise=FALSE}.
  \end{itemize}

 \item \verb!marks<-.tess!:
    A tessellation can now have any kind of marks
    (vector, list, data frame or hyperframe).
   
 \item \texttt{markstat}:
   Now works for point patterns in three dimensions (class \texttt{"pp3"})
   and point patterns on a network (class \texttt{"lpp"}).
   
\item \texttt{marktable}:
    Now works for point patterns in three dimensions (class \texttt{"pp3"})
    and point patterns on a network (class \texttt{"lpp"}).
   
 \item \texttt{markvario}:
   \begin{itemize}
   \item 
    The result now has an attribute \texttt{smooth.args}
    containing the smoothing parameters used.
   \item 
     Accepts the argument \texttt{weights} 
     which is passed to \texttt{markcorr}.
   \end{itemize}

 \item \texttt{mincontrast}:
   New argument \texttt{action.bad.values} specifies what action is taken
    when the summary function produces \texttt{NA} or \texttt{NaN}
    or infinite values.
    
 \item \texttt{minnndist}, \texttt{maxnndist}:
   New  argument \texttt{by} makes it possible to find the minimum or maximum
   nearest neighbour distance between each pair of possible types
   in a multitype pattern.

 \item \texttt{model.images.ppm}:
    Now recognises arguments passed to \texttt{as.mask}
    to control the pixel raster for the images.
    
 \item \texttt{mppm}:
   \begin{itemize}
   \item 
     The responses can be point patterns on a linear network
     (objects of class \texttt{"lpp"}).
   \item 
     Recognises argument \texttt{quad.args}.
   \item 
     Now handles models with a random effect component.
     (This is covered in \cite[Chap.\ 16]{baddrubaturn15}.)
   \item 
     New argument \texttt{random} is a formula specifying the random effect.
     (This is covered in \cite[Chap.\ 16]{baddrubaturn15}.)
   \item 
     Performs more checks for consistency of the input data.
   \item 
     New arguments \texttt{gcontrol} and \texttt{reltol.pql} control 
     the fitting algorithm. 
   \item 
     New argument \texttt{weights} specifies case weights for each row of data.
   \end{itemize}

 \item \texttt{msr}:
    Infinite and \texttt{NA} values are now detected (if \texttt{check=TRUE})
    and are reset to zero, with a warning.
    
    
  \item \texttt{multiplicity}:
    Methods for \texttt{multiplicity} can now handle objects of larger size.
    
%%N
   
   \item \texttt{nbfires}:
     \begin{itemize}
     \item 
     the unit of length for the coordinates is now specified in this dataset.
   \item This dataset now includes information about the different 
    land and sea borders of New Brunswick.
   \end{itemize}

   
 \item \texttt{nncorr,nnmean,nnvario}:
   New argument \texttt{na.action}.
   
 \item \texttt{nncross.default}:
   \begin{itemize}
   \item 
   New option \texttt{squared=TRUE}
   returns the squared nearest neighbour distances,
   reducing computation time.
 \end{itemize}
 
 \item \texttt{nncross.lpp}:
   \begin{itemize}
   \item    New argument \texttt{k} allows computation of $k$-th nearest point.
   \item    Computation accelerated.
   \end{itemize}

 \item \texttt{nncross.ppp}:
   \begin{itemize}
   \item 
   New option \texttt{squared=TRUE}
   returns the squared nearest neighbour distances,
   reducing computation time.
   \item slightly accelerated.
%   \item new argument \texttt{dmax}.
   \item 
   When \texttt{X} is a point pattern and \texttt{Y} is a line segment pattern,
    higher order neighbours (\verb!k > 1!) are now supported.
   \end{itemize}

    
 \item \texttt{nndist.default}:
   New option \texttt{squared=TRUE}
   returns the squared nearest neighbour distances,
   reducing computation time.

 \item \texttt{nndist.ppp}:
   \begin{itemize}
   \item 
     New option \texttt{squared=TRUE}
     returns the squared nearest neighbour distances,
     reducing computation time.
   \item 
   New argument \texttt{proper}.
   \end{itemize}

 \item \texttt{nndist.pp3}:
   New argument \texttt{by} allows computation of the nearest 
     distance to each group of points.

 \item \texttt{nndist.ppx}:
   New argument \texttt{by} allows computation of the nearest 
     distance to each group of points.

 \item \texttt{nndist.lpp}:
   \begin{itemize}
   \item    New argument \texttt{k} allows computation of $k$-th nearest point.
   \item new argument \texttt{by} allows computation of the nearest 
     distance to each group of points.
   \item    Computation accelerated.
   \end{itemize}

 \item \texttt{nnmap.ppp}:
       New option \texttt{squared=TRUE} returns the squared distances,
    reducing computation time.

    
 \item \texttt{nnwhich.lpp}:
   \begin{itemize}
   \item    New argument \texttt{k} allows computation of $k$-th nearest point.
   \item new argument \texttt{by} allows computation of the nearest 
     distance to each group of points.
   \item    Computation accelerated.
   \end{itemize}

  
 \item  \texttt{nnfun}: new argument \texttt{rule.eps}.


   \texttt{nnfun.lpp}: 
   \begin{itemize}
   \item New argument \texttt{k}.
   \item New argument \texttt{value} specifies whether to return the
     index of the nearest neighbour or the mark value of the nearest
     neighbour.
   \end{itemize}

   \texttt{nnfun.ppp}: 
   \begin{itemize}
   \item New argument \texttt{value} specifies whether to return the
     index of the nearest neighbour or the mark value of the nearest
     neighbour.
   \end{itemize}

   \texttt{nnfun.psp}: 
   \begin{itemize}
   \item New argument \texttt{value} specifies whether to return the
     index of the nearest neighbour or the mark value of the nearest
     neighbour.
   \end{itemize}
   
%%O
   
   \item \texttt{owin}:
     \begin{itemize}
     \item 
       accelerated in many cases.
     \item 
       If argument \texttt{mask} is a logical matrix,
       \texttt{NA} entries will be accepted, and converted to \texttt{FALSE}.
     \end{itemize}
    
   \item \texttt{owin2mask}:
     \begin{itemize}
     \item 
       Arguments \texttt{'...'} that are not recognised by \texttt{as.mask}
       are now silently ignored, rather than causing an error.
     \item 
       New options \texttt{op="majority"} and \texttt{op="minority"}.
       If \texttt{op="majority"}, a pixel belongs to the resulting mask if
       at least half of the pixel area is covered by the window.
     \item 
        Changed formal arguments. First argument is now called \texttt{w}.
        Formal argument \texttt{op} renamed \texttt{rule.pix}.
        All arguments must be given by name except for the first argument.
     \end{itemize}
     
%%P
   
 \item \texttt{padimage}:
   New argument \texttt{W} allows an image to be padded out to fill any window.

   
 \item \texttt{pairdist.lpp}: 
   Now handles much larger networks, using the sparse representation
   of the network.

 \item \texttt{pairorient}: Default edge corrections now include 
   \texttt{"bord.modif"}.
   
   
 \item \texttt{pairs.im}: new argument \texttt{drop}.
   
 \item \texttt{parres}: 
   the argument \texttt{covariate} is allowed to be missing
   if the model only depends on one covariate.
   
 \item \texttt{pcf.ppp}:
   \begin{itemize}
   \item The default value of \texttt{divisor} has temporarily reverted to 
     \texttt{"r"} pending further investigation.
   \item Changed rule for converting bandwidths when 
     \texttt{divisor="a"}.
   \item The default value of \texttt{divisor} has changed to \texttt{"a"},
    so that the new area-based estimator is the default.
  \item
    The default value of \texttt{zerocor} is now \texttt{"JonesFoster"}
    for small patterns and \texttt{"convolution"} for larger patterns.
  \item 
    New argument \texttt{nsmall} determines the threshold for large patterns.
   \item New option: \texttt{divisor="a"} calculates a new estimator of the pcf
    with improved performance.
   \item 
     New argument \texttt{ratio} allows several estimates of pcf to be pooled.
   \item 
     Now calculates an analytic approximation to the variance of
     the estimate of the pair correlation function 
     (when \texttt{var.approx=TRUE}).
   \item 
     Now returns the smoothing bandwidth used, as an attribute of the result.
   \item 
     New argument \texttt{close} for advanced use.
   \item Now accepts \texttt{correction="none"}.
   \end{itemize}

 \item \texttt{pcfcross}, \texttt{pcfdot}:
   Shortened list of formal arguments (other arguments pass to
   \texttt{pcfmulti}).
   
 \item \texttt{pcfcross}, \texttt{pcfdot}, \texttt{pcfmulti}:
   \begin{itemize}
   \item The default value of \texttt{divisor} has temporarily reverted to 
     \texttt{"r"} pending further investigation.
   \item The default estimation method has changed. The new default is
    based on squared distances (\texttt{divisor="a"}).
   \item 
   New argument \texttt{ratio} makes it possible to save the numerator and
   denominator of the function estimates, so that estimates can be pooled.
   \end{itemize}
    
 \item \texttt{pcfcross.inhom}, \texttt{pcfdot.inhom}:
   \begin{itemize}
   \item Shortened list of formal arguments (other arguments pass to
   \texttt{pcfmulti.inhom}).
   \item The default value of \texttt{divisor} has temporarily reverted to 
     \texttt{"r"} pending further investigation.
   \item The default estimation method has changed. The new default is
    based on squared distances (\texttt{divisor="a"}).
   \item 
   New arguments \texttt{adjust.sigma} and \texttt{adjust.bw} allow
   separate adjustment of the one-dimensional smoothing bandwidth \texttt{bw}
    and the spatial smoothing bandwidth \texttt{sigma}.
   \end{itemize}


 \item \texttt{pcfinhom}:
   \begin{itemize}
   \item The default value of \texttt{divisor} has temporarily reverted to 
     \texttt{"r"} pending further investigation.
   \item The default value of \texttt{divisor} has changed to \texttt{"a"},
    so that the new area-based estimator is the default.
  \item
    The default value of \texttt{zerocor} is now \texttt{"JonesFoster"}
    for small patterns and \texttt{"convolution"} for larger patterns.
  \item 
    New argument \texttt{nsmall} determines the threshold for large patterns.
  \item Default value of \texttt{normpower} has changed to 2.
   \item New option: \texttt{divisor="a"} calculates a new estimator of the pcf
    with improved performance.
   \item  
     New arguments \texttt{adjust.sigma} and \texttt{adjust.bw} allow
    separate adjustment of the one-dimensional smoothing bandwidth \texttt{bw}
    and the spatial smoothing bandwidth \texttt{sigma}.
   \item
	New argument \code{close} for advanced use.
   \item 
    Default behaviour is changed when \texttt{lambda} is a fitted model.
    The default is now to re-fit the model to the data before computing pcf.
    New arguments \texttt{update} and \texttt{leaveoneout} control this.
   \item 
     New argument \texttt{close} for advanced use.
   \item Now handles \texttt{correction="good"}
 \item 
   Leave-one-out calculation is implemented when \texttt{lambda}
   is a fitted model of class \texttt{"dppm"}.
   \end{itemize}

   
 \item \texttt{pcfmulti}:
       New arguments \texttt{h}, \texttt{bw.args}, \texttt{adjust}, 
       \texttt{zerocor}, \texttt{nsmall}, \texttt{gref}, 
       \texttt{tau}, \texttt{close}.
       
 \item \texttt{pcfmulti}:
   \begin{itemize}
   \item 
     Interpretation of arguments \texttt{lambdaI}, \texttt{lambdaJ}, 
     \texttt{lambdaX}, \texttt{lambdadot}
     has changed when they are fitted point process models. If the model is
     a multitype point process then it is assumed to be a model for the 
     entire point pattern \texttt{X}, 
     while if the model is an unmarked point process
     then it is assumed to be a model for the relevant subset of the data.
   \item 
       New arguments \texttt{h}, \texttt{bw.args}, \texttt{adjust}, 
       \texttt{zerocor}, \texttt{nsmall}, \texttt{gref}, 
       \texttt{tau}, \texttt{close}.
   \end{itemize}
   
 \item \texttt{persist}: Now accepts an object of class \texttt{"clustermodel"}.
   
 \item \code{persp.funxy}:
   Improved $z$-axis label.
   
 \item \code{persp.im}:
   \begin{itemize}
   \item The pixel values of \texttt{colin} can be colour values.
     New argument \texttt{valuesAreColours}.
   \item     Now recognises argument \texttt{adj.main}
     controlling the position of main title.
   \item     Improved appearance when \texttt{apron=TRUE}
     and the image domain is not a rectangle.
   \end{itemize}

 \item \code{persp.linim}:
   \begin{itemize}
   \item  Improved behaviour close to vertices of the network.
   \item  New arguments \texttt{extrapolate} and \texttt{zadjust}.
   \item Argument \texttt{col.base} can be a pixel image, allowing
     a colour image to be plotted on the horizontal plane at height zero.
   \end{itemize}

   
 \item \code{persp.ppp}:
   \begin{itemize}
   \item Now plots the \texttt{zlab} label alongside the vertical scale bar.
   \item Argument \texttt{col.base} can be a pixel image, which will be
     rendered as a colour image in perspective view on the horizontal plane.
   \item New argument \texttt{show.window}.
   \item 
     Now recognises argument \texttt{adj.main}
     controlling the position of main title.
   \end{itemize}
   
  \item \texttt{pixellate.owin}:
    \begin{itemize}
    \item Now accepts the argument \texttt{rule.pix} passed 
      to \texttt{owin2mask}.
      This makes it possible to ensure that boundary pixels which partially
      intersect the window are included in the resulting pixel image,
      by setting \texttt{rule.pix="cover"}.
    \end{itemize}
    
  \item \texttt{pixellate.ppp}:
    \begin{itemize}
    \item Now accepts the argument \texttt{rule.pix} passed 
      to \texttt{owin2mask}.
      This makes it possible to ensure that boundary pixels which partially
      intersect the window are included in the resulting pixel image,
      by setting \texttt{rule.pix="cover"}.
    \item If the pattern is empty, the result is an integer-valued image
    (by default) for consistency with the results for non-empty patterns.
    \item      Accelerated in the case where weights are given.
    \item New arguments \texttt{fractional} and \texttt{preserve}
      for more accurate discretisation.
    \item New argument \texttt{savemap}.
    \end{itemize}

  \item \texttt{pixellate.psp}:
    \begin{itemize}
    \item Now accepts the argument \texttt{rule.pix} passed 
      to \texttt{owin2mask}.
      This makes it possible to ensure that boundary pixels which partially
      intersect the window are included in the resulting pixel image,
      by setting \texttt{rule.pix="cover"}.
    \end{itemize}
  
  \item \texttt{pixelquad}:
    Now accepts arguments passed to \texttt{as.mask}
    to control the pixel resolution.

 \item \texttt{plot.anylist}:
   \begin{itemize}
   \item 
   If a list entry \verb!x[[i]]! 
   belongs to class \texttt{"anylist"}, it will be expanded
   so that each entry \verb!x[[i]][[j]]! will be plotted as a separate panel.
   \item 
     New arguments \texttt{panel.begin.args}, \texttt{panel.end.args}
   \item  Result is now an (invisible) list containing the result
    from executing the plot of each panel.
   \end{itemize}
   
   
 \item \texttt{plot.bermantest}:
   Improved layout for plots of Berman's \texttt{Z2} test.

 \item \texttt{plot.colourmap}:
   \begin{itemize}
   \item New argument \texttt{do.plot}
   \item New formal argument \texttt{side}.
   \item Now handles a colour map for a zero-length interval [a,a]
   \item 
   New argument \texttt{increasing} specifies whether the colours are
    displayed in order left-to-right/bottom-to-top.
  \item 
    Changed default behaviour for discrete colour maps 
    when \texttt{vertical=FALSE}.
  \item 
    New argument \texttt{nticks} controls the number of axis tick marks
    when the colourmap is defined on a continuous range of numerical values.
  \item 
    New argument \texttt{box} controls whether a box will be drawn
    around the colours.
  \item 
    New argument \texttt{at} determines the position of tick marks on the axis.
   \end{itemize}

 \item \texttt{plot.fv}:
   \begin{itemize}
   \item New argument \texttt{do.plot}.
   \item 
     New argument \texttt{clip.xlim}.
   \end{itemize}
   
 \item \texttt{plot.im}:
   \begin{itemize}
   \item New argument \texttt{opacity} controls semi-transparency of colours.
   \item The position of text next to the colour ribbon can now be
     controlled by \verb!riblab$side!. 
   \item Placement of main title improved in some cases.
   \item New arguments \texttt{background} and \texttt{clip.background} 
     allow the user to specify an object that will be plotted before the
     image \texttt{x}, and will therefore appear underneath it.
   \item 
     New argument \texttt{drop.ribbon} determines whether a ribbon
     will be displayed
     in the case where the pixel values are all equal.
     Default behaviour has changed.
   \item 
     New argument \texttt{reverse.col} allows the sequence of colours
     to be reversed.
   \item 
     New argument \texttt{addcontour} specifies that contour lines should be drawn
    over the image plot.
   \item  Now handles complex-valued images.
   \item  New argument \texttt{workaround} to avoid a bug in some MacOS
     device drivers that causes the image to be displayed
     in the wrong spatial orientation.
   \item The number of tick marks in the colour ribbon can now be controlled
    using the argument \texttt{nint} in \texttt{ribargs}.
  \item Improved behaviour when all pixel values are \texttt{NA}.
  \item Improved handling of tickmarks on colour ribbon.
  \item Improved behaviour when the image values are almost constant.
  \item New argument \texttt{riblab}.
  \item Axes are prevented from extending outside the image rectangle.
  \item New argument \texttt{zap}.
  \item Some warnings are suppressed when \texttt{do.plot=FALSE}.
  \item Return value has attribute \texttt{"at"} giving the position of 
    the tick marks on the axis next to the colour ribbon.
   \end{itemize}

 \item \texttt{plot.imlist}:
   \begin{itemize}
   \item New argument \texttt{equal.scales}.
   \item If \texttt{equal.ribbon=TRUE} and \texttt{equal.scales=TRUE},
         the colour ribbon
         is now neatly aligned with the plotted images.
   \item Result is now an (invisible) list containing the results
   from executing the plot of each panel.
   \end{itemize}

 \item \texttt{plot.influence.ppm}:
   New argument \texttt{multiplot}.

 \item \texttt{plot.kppm}:
   \begin{itemize}
   \item 
   New arguments \texttt{pause} and \texttt{xname}.
 \item 
    The argument \texttt{what="all"} is now recognised: it selects
    all the available options. [This is also the default.]
   \end{itemize}

 \item \texttt{plot.leverage.ppm}:
   \begin{itemize}
   \item 
   New arguments \texttt{multiplot} and \code{what}.
   \item
   A contour line showing the average value of leverage
   is now drawn on the colour ribbon, as well as on the main image.
   New argument \texttt{args.contour}.
 \end{itemize}


 \item \texttt{plot.linfun}:
   \begin{itemize}
   \item  Now passes arguments to the function being plotted.
   \item A scale bar is now plotted when \texttt{style="width"}.
   \item New argument \texttt{legend}.
   \item The return value has a different format.
  \end{itemize}

 \item \texttt{plot.linim}:
   \begin{itemize}
   \item  The return value has a different format.
   \item New argument \texttt{fatten} improves visual appearance
     when \texttt{style="colour"}.
   \item A scale bar is now plotted when \texttt{style="width"}.
   \item When \texttt{style="width"}, negative values are plotted in
     red (by default). New argument \texttt{negative.args} controls this.
   \item New argument \texttt{zlim} specifies the range of values to be mapped.
   \item New explicit argument \texttt{box} determines whether to plot a 
     bounding box; default is \texttt{FALSE} in all cases.
   \end{itemize}

 
 \item \texttt{plot.linnet}:
   \begin{itemize}
   \item New argument \texttt{adj.main}.
   \end{itemize}
   
 \item \texttt{plot.lintess}:
   \begin{itemize}
   \item Improved plot method, with more options.
   \item Modified to display the marks attached to the tiles.
   \item Options: \verb!style=c("colour", "width", "image")!.
   \end{itemize}


   \item \texttt{plot.lpp}:
     \begin{itemize}
   \item New argument \texttt{adj.main}.
     \item New argument \texttt{show.network}.
     \item 
     For a point pattern with continuous marks (``real numbers'')
    the colour arguments \texttt{cols}, \texttt{fg}, \texttt{bg} can now 
    be vectors of colour values, and will be used to determine
    the default colour map for the marks.
     \item If \texttt{shape="crossticks"}, the points will be drawn as
       short line segments perpendicular to the network.
     \end{itemize}

   \item \texttt{plot.mppm}:
     \begin{itemize}
     \item New argument \texttt{main}.
     \item New argument \texttt{se}.
     \end{itemize}
   
   \item \texttt{plot.msr}:
     \begin{itemize}
     \item  Now handles multitype measures.
     \item New argument \texttt{multiplot}.
     \item New argument \texttt{massthresh}.
     \item New arguments \texttt{equal.markscale} and \texttt{equal.ribbon}.
     \end{itemize}

     
   \item \texttt{plot.onearrow:} 
     Graphical parameters, specified when the object was created,
     are now taken as the defaults for graphical parameters to the plot.

   \item \texttt{plot.owin:} 
     \begin{itemize}
     \item 
       New argument \texttt{use.polypath} controls how to plot
       a filled polygon when it has holes.
     \item 
       New argument \texttt{adj.main} controls the justification of the text
       in the main title.
     \item 
       New argument \texttt{background} specifies an object (or a colour)
       that will be plotted before \texttt{x} is plotted, and will
       therefore appear underneath it.
     \end{itemize}
     
  \item \texttt{plot.profilepl}:
        This function has now been documented, and the graphics improved.
        
  \item \texttt{plot.psp}:
    \begin{itemize}
     \item New argument \texttt{scramble.cols}
    \item Segments can be plotted with widths proportional to their mark values.
    \item New argument \texttt{style}.
    \item New argument \texttt{col} gives control over the colour map
      representing the values of marks attached to the segments.
    \item The code for \texttt{style="width"} has been completely rewritten,
    so that it no longer depends on \texttt{plot.linim}, 
    and is much more efficient.
  \item The formal argument list has been extended.
     \item 
       New argument \texttt{background} specifies an object (or a colour)
       that will be plotted before \texttt{x} is plotted, and will
       therefore appear underneath it.
    \end{itemize}

  \item \texttt{plot.pp3}:
    New arguments \texttt{box.front}, \texttt{box.back} 
    control plotting of the box.
    
   \item \texttt{plot.ppp}:
     \begin{itemize}
     \item New argument \texttt{show.rejects}.
     \item New argument \texttt{scramble.cols}
     \item New arguments \texttt{background} and \texttt{clip.background} allow
       the user to specify an object (or a colour value)
       that will be plotted before the point 
       pattern \texttt{x}, and will therefore appear underneath it.
     \item  For multitype point patterns, a warning is issued if 
    the plot legend does not represent every possible type of point
    due to space restrictions.
     \item  The default colour for the points is now a transparent grey,
       if this is supported by the plot device.
     \item For a point pattern with continuous marks (``real numbers'')
       the colour arguments \texttt{cols}, \texttt{fg}, \texttt{bg} can now 
       be vectors of colour values, and will be used to determine
       the default colour map for the marks.
     \item Now recognises graphics parameters for text, such as 
       \texttt{family} and \texttt{srt}
     \item 
       When \texttt{clipwin} is given, any parts of the boundary 
       of the window of \texttt{x} that lie inside \texttt{clipwin} 
       will also be plotted.
     \item 
       Improved placement of symbol map legend when argument \texttt{symap} is given.
     \end{itemize}

  \item \code{plot.tess}:
    \begin{itemize}
    \item This plot method can now fill each tile with a different colour.
    \item     New arguments \code{do.col}, \code{values}, \code{col} and 
      \code{ribargs}.
      Old argument \code{col} has been renamed \code{border} for consistency.
    \item  Now generates a separate plot panel for each column of marks,
    if \texttt{do.col=TRUE}.
  \item New argument \texttt{multiplot}.
  \item Changed the default values for \code{do.col} and \code{do.labels}.
    \end{itemize}

  \item \texttt{plot.palmdiag}: 
    \begin{itemize}
    \item Improved calculation of $y$ axis limits.
    \item Improved rule for automatic placement of legend.
    \end{itemize}

    
   \item \texttt{plot.profilepl} ,\texttt{plot.quadratcount}, 
     \texttt{plot.quadrattest}, \texttt{plot.tess}:
     Now recognise graphics parameters for text, such as 
    \texttt{family} and \texttt{srt}

    \item \texttt{plot.solist}:
      \begin{itemize}
      \item 
        Arguments \texttt{adorn.left}, \texttt{adorn.right}, 
        \texttt{adorn.bottom}, \texttt{adorn.top}
        may now be objects of class \texttt{colourmap} or \texttt{symbolmap}.
      \item New argument \texttt{adorn.args}.
      \item When \texttt{equal.ribbon=TRUE}, the images may now be factor-valued
        or character-valued. Character-valued images will be converted
        to factor-valued images. The common colour map will combine the
        levels of all the factor images. 
      \item 
        New arguments \texttt{panel.begin.args}, \texttt{panel.end.args}
      \item 
        Result is now an (invisible) list containing the result
        from executing the plot of each panel.
      \end{itemize}

    \item \texttt{plot.studpermutest}: This existing function now has a
      help file.
      
    \item \texttt{plot.symbolmap}:
      \begin{itemize}
      \item New argument \texttt{do.plot}.
      \item New formal argument \texttt{side}.
      \item New argument \texttt{colour.only} makes
        it possible to display only the colour map information in a symbol map.
      \item New argument \texttt{warn}.
      \item Issues a warning if the plot of a discrete symbol map does not
        represent every possible input value, due to space restrictions.
      \item New argument \texttt{nsymbols} controls the number of symbols plotted.
      \end{itemize}

    \item \texttt{plot.texturemap}:
      new formal argument \texttt{side}.
      
    \item \texttt{plot.yardstick}:
      \begin{itemize}
      \item 
        new argument \texttt{style} allows different styles of
        plotting a scale bar, including a zebra pattern 
        (\texttt{style = "zebra"}).
      \item 
        New arguments \texttt{zebra.step}, \texttt{zebra.width}, 
        \texttt{zebra.col}.
      \end{itemize}
      
   \item \code{ponderosa}:
    In this installed dataset, the function \code{ponderosa.extra\$plotit}
    has changed slightly (to accommodate the
    dependence on the package \pkg{spatstat.utils}).
   \item \texttt{polynom}: This function now has a help file.
     
   \item \texttt{pool.fv}:
     \begin{itemize}
     \item 
    The default plot of the pooled function no longer includes 
    the variance curves.
  \item  New arguments \texttt{relabel} and \texttt{variance}.
     \end{itemize}

   \item \texttt{pool.rat}:
     New arguments \texttt{weights}, \texttt{relabel} and \texttt{variance}.

  \item \texttt{ppm}:
    \begin{itemize}
    \item Now supports regularized model-fitting.
    \item Huang-Ogata approximate maximum likelihood can be applied to logistic fits.
    \item New argument \texttt{improve.type}. 
      \begin{itemize}
      \item Option \texttt{method="ho"} is replaced by \texttt{improve.type="ho"}.
      \item Regularized model-fitting is performed when \texttt{improve.type="enet"}.
      \item Huang-Ogata approximate maximum likelihood can be applied to logistic fits
        by setting \texttt{method="logi"} and \texttt{improve.type="ho"}.
      \end{itemize}
    \item 
      Argument \code{interaction} can now be a function that makes an interaction,
      such as \code{Poisson}, \code{Hardcore}, \code{MultiHard}.
    \item 
      Argument \texttt{subset} can now be a window (class \texttt{"owin"})
      specifying the sub-region of data to which the model should be fitted.
    \end{itemize}

  \item \texttt{ppm.ppp, ppm.quad}:
    \begin{itemize}
    \item 
      New argument \texttt{emend}, equivalent to \texttt{project}.
    \item 
      New arguments \texttt{subset} and \texttt{clipwin}.
    \item 
      New argument \texttt{quad.args} is a list of arguments passed
      to \texttt{quadscheme} to control the construction of the quadrature 
      scheme. 
    \end{itemize}

  \item \code{ppmInfluence}:
    The result now belongs to class \code{ppmInfluence}, for which there are
    methods for \code{leverage}, \code{influence}, \code{dfbetas}
    which extract the desired component.
  
 \item \texttt{ppp}:
       \begin{itemize}
       \item New argument \texttt{checkdup}.
       \item 
       If the coordinate vectors \code{x} and \code{y} contain \code{NA},
       \code{NaN} or infinite values,
       these points are deleted with a warning,
       instead of causing a fatal error.
       \end{itemize}

  \item \texttt{pp3}:
    New argument \texttt{marks}.
    
  \item \texttt{predict.kppm, residuals.kppm}
   Now issues a warning when the calculation ignores the 
   cluster/Cox component and treats the model as if it were Poisson.
   (This currently happens in predict.kppm when se=TRUE or interval != "none",
   and in residuals.kppm when type != "raw").

  \item \texttt{predict.lppm}:
    Argument \texttt{locations} can now be an \texttt{lpp} object.

  \item \texttt{predict.mppm}:
    \begin{itemize}
    \item 
    The argument \texttt{type="all"} is now recognised: it selects
    all the available options. [This is also the default.]
  \item Now supports multitype point process models.
  \item Improved handling of argument \texttt{newdata}.
    \end{itemize}

  \item \texttt{predict.ppm}:
    \begin{itemize}
    \item    Now recognises the arguments 
      \code{dimyx} and \code{eps} for specifying the
      resolution of the grid of prediction points.
    \item New argument \code{ignore.hardcore}.
    \item Accelerated for models fitted with \texttt{method="VBlogi"}
    \item Standard error calculation (\texttt{se=TRUE}) now works 
      for models fitted with \texttt{use.gam=TRUE}.
    \end{itemize}

  \item \texttt{predict.rhohat}:    
     New argument \texttt{what} determines which value should be calculated:
    the function estimate, the upper/lower confidence limits, or the
    standard error.

  \item \texttt{predict.slrm}:    
    \begin{itemize}
    \item New argument \texttt{leaveoneout} 
       supports ``leave-one-pixel-out'' prediction.
    \item New argument \texttt{fast} 
      determines algorithm used when \texttt{leaveoneout=TRUE}.
    \end{itemize}

  \item \texttt{print.kppm}: Additional characteristics of the fitted model
    are reported,
    including the cluster strength \texttt{phi} and the sibling probability.

  \item \texttt{print.linim}: More information is printed.

  \item \texttt{print.lintess}:
    \begin{itemize}
    \item Output improved.
    \item Output includes information about marks.
    \end{itemize}


  \item \texttt{print.lppm}: The name of the original point pattern dataset 
    (to which the model was fitted) is now printed.
    
  \item \texttt{print.quad}: More information is printed.

  \item \texttt{print.rmhmodel}: More information is printed.

  \item \texttt{print.slrm}: Prints information about the pixel raster.
    
  \item \texttt{print.summary.owin}:
    Output can now be abbreviated by
    increasing the value of \texttt{spatstat.options('terse')}
    
  \item \texttt{print.summary.psp}:
    Output can now be abbreviated by
    increasing the value of \texttt{spatstat.options('terse')}
    
  \item \texttt{progressreport}
    \begin{itemize}
    \item  The estimated time of completion is also printed, 
      if the remaining time is longer than 10 minutes.
    \item Behaviour improved. 
    \item New arguments \texttt{state}, \texttt{tick}, \texttt{showtime}.
    \item New option: \verb!style="tk"!
    \item New argument \texttt{formula} controls the calculation 
      of estimated time remaining. 
    \item 
      New argument \texttt{savehistory}
      specifies whether to save the elapsed times
      when the function was called.
    \end{itemize}

  \item \texttt{projectsegment}: Accelerated by 20 percent.

  \item \texttt{projectset}: Supports projection to a polygonal window;
    new argument \texttt{polygonal}.
    
  \item \code{pseudoR2.ppm}, \code{pseudoR2.lppm}:
    \begin{itemize}
    \item     The null model now includes any offset terms, by default.
    \item     New argument \code{keepoffset}.
    \end{itemize}
    
    
  \item \texttt{psib}: Now accepts an object of class \texttt{"clustermodel"}.

%%Q

    
  \item \texttt{quadform}: This function has been moved
    to the sub-package \texttt{spatstat.sparse}.
    
 \item \texttt{quadratcount.ppp}:
   \begin{itemize}
   \item    Computation accelerated in some cases.
   \item New argument \texttt{left.open} controls the treatment of data points
    which lie on the boundary between two rectangular quadrats.
   \end{itemize}



 \item \texttt{quadrat.test.ppm}:
   Computation accelerated in some cases.

 \item \texttt{quantess}: 
   \begin{itemize}
   \item The covariate \texttt{Z}
     can now be \texttt{"rad"} or \texttt{"ang"} representing polar coordinates.
   \item New argument \texttt{origin} specifies the origin of polar coordinates.
   \item New argument \texttt{eps} controls the accuracy of the calculation.
   \end{itemize}
   
 \item \texttt{quantile.ecdf}:
   \begin{itemize}
   \item Now supports \texttt{type=4} (linear interpolation).
   \end{itemize}
 
 \item \texttt{quantile.ewcdf}:
   \begin{itemize}
   \item Now supports \texttt{type=4} (linear interpolation).
   \item 
    The function is now normalised to the range \verb![0,1]!
    before the quantiles are computed. 
    This can be suppressed by setting \texttt{normalise=FALSE}.
   \end{itemize}

 \item \texttt{qqplot.ppm}
    Argument \texttt{expr} can now be a list of point patterns,
    or an envelope object containing a list of point patterns.
    
%%R
   
  \item Most random generators: now accept \texttt{nsim=0} 
    and return a zero-length list.
    
  \item \texttt{rbind.hyperframe}:
    The result now retains the \texttt{row.names}
    of the original arguments.
    

   \item \texttt{rcellnumber}:
     New argument \texttt{mu}.

   \item \texttt{rebound.owin}: Now preserves unitnames of the objects.
     
     
   \item \texttt{relrisk.lpp}:
     Argument \texttt{weights} can be logical valued.

   \item \texttt{relrisk.ppp}:
     \begin{itemize}
     \item Now accepts argument \texttt{rule.pix} passed to \texttt{owin2mask}.
     \item New argument \texttt{shrink} supports Bithell's shrinkage estimator.
     \item New argument \texttt{normalise} controls whether the estimate 
       will be normalised so that constant relative risk
       corresponds to the value 1.
     \end{itemize}

   \item \texttt{rescale.owin}, \texttt{rescale.ppp}, \texttt{rescale.psp}:
     The geometrical type of the window is now preserved in all cases.
     (Previously if the window was polygonal but was equivalent to a 
     rectangle, the rescaled window was a rectangle.)
     
   \item \texttt{reload.or.compute}:
     New argument \texttt{exclude} specifies which objects should not be saved.
     
   \item \texttt{residualMeasure}:
     More options for argument \texttt{lambda}.
     
   \item \texttt{rgbim, hsvim}:
   New argument \texttt{A} controls the alpha (transparency) channel.

   \item \texttt{rgb2hex, col2hex, paletteindex, is.colour, samecolour,}
   \texttt{complementarycolour, is.grey, to.grey}
   These colour tools now handle transparent colours.

   \item \texttt{rgb2hex}:
   New argument \texttt{maxColorValue}

   \item \texttt{relrisk.ppp}:
     \begin{itemize}
     \item 
       If \texttt{se=TRUE} and \texttt{at="pixels"}, the result belongs
       to class \texttt{solist}.
     \item
       The arguments \texttt{adjust}, \texttt{edge}, \texttt{diggle}
       are now explicit formal arguments.
     \item 
       New argument \texttt{weights}.
     \item
       Ratios which are close to 0/0 are handled more effectively,
       reducing the likelihood of strange-looking plots when \texttt{sigma} is very small.
     \item     Issues a warning if numerical underflow is detected.
     \item 
       The interpretation of \texttt{weights} in the calculation of
       standard error has changed. New argument \texttt{wtype}
       controls this interpretation.
     \item 
       New argument \texttt{fudge} specifies a constant numeric value
       that will be added to each estimate of point process intensity
       before calculation of relative risk.
     \end{itemize}
     
   \item 
   \texttt{rhohat}:
   \begin{itemize}
   \item The result now includes the ``average'' intensity $\overline\rho$.
   \item 
     New options \texttt{smoother="piecewise"} 
     computes a piecewise-constant estimate of $\rho(z)$.
   \item Nonparametric maximum likelihood estimation is now supported,
     assuming the intensity is a monotone function of the covariate.
   \item
     New options \texttt{smoother="increasing"} 
     and \texttt{smoother="decreasing"} for estimating
     a monotone increasing or monotone decreasing curve.
   \item
     New options \texttt{smoother="mountain"} 
     and \texttt{smoother="valley"}
     for estimating a unimodal function (U-shaped or inverted-U-shaped curve).
   \item 
   New argument \texttt{subset} allows computation for a subset of the data.
   \item
   New argument \texttt{positiveCI} specifies whether confidence limits
   should always be positive. 
 \item If the covariate is a \texttt{distfun}, the name of the unit of length
   is saved and displayed on the plot.
 \item New argument \texttt{rule.eps} passed to \texttt{as.mask}.
   \end{itemize}
   
   \item \texttt{rhohat.lpp}:
     \begin{itemize}
     \item  New argument \texttt{random} controls placement of dummy points. 
     \item  New argument \texttt{rule.eps} passed to \texttt{as.mask}.
    \end{itemize}

   \item \texttt{rhohat.lppm}:
     \begin{itemize}
     \item  New argument \texttt{rule.eps} passed to \texttt{as.mask}.
    \end{itemize}


 \item\texttt{rhohat.ppm}:
   New argument \texttt{rule.eps} passed to \texttt{as.mask}.
   
 \item \texttt{rjitter.ppp}:  If \texttt{trim=TRUE}, 
   the displacement radius will be constrained
   to be less than or equal to the distance from the data point
   to the window boundary. This guarantees that all displaced points fall
   inside the window, and accelerates the computation.
   
   \item \texttt{rlabel}: 
     \begin{itemize}
     \item New argument \texttt{group} specifies that the points are 
       divided into several groups, and that relabelling is applied
       within each group.
       
     \item New arguments \texttt{nsim} and \texttt{drop}.
     \item 
       \texttt{X} can now be a point pattern of any type
       (\texttt{ppp}, \texttt{lpp}, \texttt{pp3}, 
       \texttt{ppx}) or a line segment pattern (\texttt{psp}).
     \end{itemize}

     \item \texttt{rlabel.ppp}:
       New argument \texttt{group} specifies that the points are divided into
       several groups, and that relabelling is applied within each group.
     
     \item \texttt{rLGCP}:
       \begin{itemize}
       \item New arguments \texttt{n.cond} and \texttt{w.cond}
         specify conditional simulation. Every realisation will have
         exactly \texttt{n.cond} points in total, 
         or exactly \texttt{n.cond} points inside window \texttt{w.cond}
         if it is given.
       \item 
         This function has been completely re-implemented
         so that it no longer requires the package \pkg{RandomFields},
         which is defunct (and sadly missed). 
       \item 
         The current implementation supports only the 
         \texttt{"exponential"}, \texttt{"gauss"},
         \texttt{"stable"}, \texttt{"gencauchy"} and 
         \texttt{"matern"} covariance functions.
       \item 
         Now recognises argument \texttt{rule.eps} passed to \texttt{as.mask}.
       \item 
         New arguments \texttt{n.cond} and \texttt{w.cond} specify 
         conditional simulation. Every realisation will have exactly 
         \texttt{n = n.cond} points,
         or exactly \texttt{n.cond} points inside window \texttt{w.cond}
         if it is given.
       \end{itemize}


  \item \texttt{rMaternI, rMaternII}:
    These functions can now generate random patterns in 
    three dimensions and higher dimensions, when the argument
    \texttt{win} is of class \texttt{box3} or \texttt{boxx}.

   \item \texttt{rMatClust}: 
     \begin{itemize}
     \item Can now perform conditional simulation given a
       fixed number of points.
     \item New arguments \texttt{n.cond} and \texttt{w.cond}.
     \end{itemize}
     
  \item \texttt{rmh}:
    \begin{itemize}
    \item 
      Accelerated, in the case where multiple patterns are saved 
      using \texttt{nsave}.
    \item 
      The printed output of the debugger (invoked by \texttt{snoop=TRUE})
      has been improved.
    \end{itemize}

  \item \texttt{rmhmodel.ppm}, \texttt{simulate.ppm}:
    New argument \texttt{newdata} provides support for simulating
    a fitted model in a different window.
    
  \item \texttt{rmh.ppm, rmhmodel.ppm, simulate.ppm}:
   A model fitted using the \texttt{Penttinen} interaction can now be simulated.

 \item \texttt{rmh.default, rmhmodel.default}:
   \begin{itemize}
   \item 
     These functions now recognise \verb!cif='penttinen'!
     for the Penttinen interaction.
   \item 
     New arguments \texttt{nsim}, \texttt{saveinfo}.
    \item 
      The printed output of the debugger (invoked by \texttt{snoop=TRUE})
      has been improved.
   \end{itemize}

  \item \texttt{rmhcontrol}:
    \begin{itemize}
    \item 
    New parameter \texttt{pstage} determines when to generate
    random proposal points.
  \item The parameter \texttt{nsave} can now be a vector of integers.
    \end{itemize}
    
  \item \texttt{rmpoint}:
          New argument \texttt{fail.action} specifies what to do
      if the required number of random points cannot be generated. 
    
  \item \texttt{rNeymanScott}:
    \begin{itemize}
    \item Argument \texttt{lmax} has been replaced by \texttt{kappamax}.
    \item New argument 'mumax'.    
    \end{itemize}
    
\item \texttt{roc.ppm}, \texttt{roc.kppm}, \texttt{roc.slrm}:
  \begin{itemize}
  \item New argument \texttt{baseline} allows calculation of ROC
    relative to a baseline.
  \item New argument \texttt{method} determines the estimation method.
    New options include a kernel smoothing estimate and a monotone estimate.
  \item New arguments \texttt{CI}, \texttt{alpha} for calculating 
    confidence intervals.
  \item New argument \texttt{subset} specifies a sub-region of the
    spatial domain in which the ROC should be calculated.
  \item New argument \texttt{leaveoneout} specifies whether to use
    leave-one-out estimates of intensity at the data points.
  \end{itemize}
  
  \item \texttt{roc.ppp}:
  \begin{itemize}
  \item New argument \texttt{baseline} allows calculation of ROC
    relative to a baseline.
  \item New argument \texttt{weights} for numerical weights on the data points.
  \item New argument \texttt{observations} specifies whether to use the
    exact point coordinates or pixel presence-absence indicators.
  \item New argument \texttt{method} determines the estimation method.
    New options include a kernel smoothing estimate and a monotone estimate.
  \item New arguments \texttt{CI}, \texttt{alpha} for calculating 
    confidence intervals.
  \item New argument \texttt{subset} specifies a sub-region of the
    spatial domain in which the ROC should be calculated.
  \end{itemize}

  \item \texttt{roc.lpp}:
  \begin{itemize}
  \item New argument \texttt{baseline} allows calculation of ROC
    relative to a baseline.
  \item New argument \texttt{weights} for numerical weights on the data points.
  \item New argument \texttt{method} determines the estimation method.
    New options include a kernel smoothing estimate and a monotone estimate.
  \item New arguments \texttt{CI}, \texttt{alpha} for calculating 
    confidence intervals.
  \item New argument \texttt{subset} specifies a sub-region of the
    spatial domain in which the ROC should be calculated.
  \end{itemize}

\item \texttt{roc.lppm}:
  \begin{itemize}
  \item New argument \texttt{baseline} allows calculation of ROC
    relative to a baseline.
  \item New argument \texttt{method} determines the estimation method.
    New options include a kernel smoothing estimate and a monotone estimate.
  \item New arguments \texttt{CI}, \texttt{alpha} for calculating 
    confidence intervals.
  \item New argument \texttt{subset} specifies a sub-region of the
    spatial domain in which the ROC should be calculated.
  \item New argument \texttt{leaveoneout} specifies whether to use
    leave-one-out estimates of intensity at the data points.
  \end{itemize}
  
  
\item \texttt{roc.slrm}:
  \begin{itemize}
  \item  Changed interpretation of argument \texttt{leaveoneout=TRUE}.
    This now performs ``leave-one-pixel-out'' calculation
    (previously it performed ``leave-one-point-out'' calculation).
  \end{itemize}

   \item \texttt{rose}
     \begin{itemize}
     \item Rose diagrams can now be computed and plotted for data
       expressed in any units with any period (such as hours in a 24-hour day).
     \item
       More options for argument \texttt{unit}.
     \item
       New argument \texttt{fullcircle}.
     \item 
       New arguments \texttt{start} and \texttt{clockwise} 
       specify the convention
       for measuring and plotting angles.
     \end{itemize}

 \item \texttt{rose.default}
   \begin{itemize}
   \item Polygons are now filled in light grey (by default)
   \item New argument \texttt{col} specifies fill colour
   \item New argument \texttt{do.ticks} controls whether ticks are drawn
   \item Concentric rings are now drawn inside the circle, for scale.
   \item New argument \texttt{do.rings}.
   \item The return value now has attribute \texttt{R} giving the radius
     of the outer circle of the diagram, and attribute \texttt{rings} 
     giving the radii of the concentric rings.
   \item New argument \texttt{root} specifies whether to apply a 
     square root transformation.
   \item    New argument \texttt{weights}.
   \end{itemize}

 \item \texttt{rose.density}
   \begin{itemize}
  \item New argument \texttt{do.ticks} controls whether ticks are drawn
   \item Concentric rings are now drawn inside the circle, for scale.
   \item New argument \texttt{do.rings}.
   \item The return value now has attribute \texttt{R} giving the radius
     of the outer circle of the diagram, and attribute \texttt{rings} 
     giving the radii of the concentric rings.
   \item New argument \texttt{root} specifies whether to apply a 
     square root transformation.
   \end{itemize}
 
 \item \texttt{rose.fv}
   \begin{itemize}
  \item New argument \texttt{do.ticks} controls whether ticks are drawn
   \item Concentric rings are now drawn inside the circle, for scale.
   \item New argument \texttt{do.rings}.
   \item The return value now has attribute \texttt{R} giving the radius
     of the outer circle of the diagram, and attribute \texttt{rings} 
     giving the radii of the concentric rings.
   \item Now plots multiple curves if there are multiple columns of values.
   \item New argument \texttt{fmla} controls which columns are plotted.
   \item Now handles envelopes (objects of class \texttt{"envelope"}) as well.
   \item New argument \texttt{root} specifies whether to apply a 
     square root transformation.
   \end{itemize}
 
 \item \texttt{rose.histogram}
     \begin{itemize}
   \item Polygons are now filled in light grey (by default)
   \item New argument \texttt{col} specifies fill colour
  \item New argument \texttt{do.ticks} controls whether ticks are drawn
   \item Concentric rings are now drawn inside the circle, for scale.
   \item New argument \texttt{do.rings}.
   \item The return value now has attribute \texttt{R} giving the radius
     of the outer circle of the diagram, and attribute \texttt{rings} 
     giving the radii of the concentric rings.
   \item New argument \texttt{root} specifies whether to apply a 
     square root transformation.
   \end{itemize}
 
 \item \texttt{rotmean}:
   \begin{itemize}
   \item New argument \texttt{padzero}. 
   \item Default behaviour has changed.
   \item Improved algorithm stability.
   \item The result now has the same \texttt{unitname} as the input object.
   \item New argument \texttt{adjust} controls the smoothing bandwidth.
   \end{itemize}

   
   \item \texttt{rpoint}:
     \begin{itemize}
     \item 
      New argument \texttt{forcewin} forces the code to use the window 
      \texttt{win} when \texttt{f} is a pixel image.
    \item 
      New argument \texttt{fail.action} specifies what to do
      if the required number of random points cannot be generated. 

    \end{itemize}

    
   \item \texttt{rpoispp}:
     \begin{itemize}
     \item 
        Improved algorithm in the case where the intensity \texttt{lambda} is
        a function of class \texttt{"tessfun"} representing a function which is
        constant on each tile of a tessellation.
     \item 
       Accelerated, when \texttt{lambda} is a pixel image.
     \end{itemize}

   \item \texttt{rpoispp3}:
     \begin{itemize}
     \item New argument \texttt{ex} (example point pattern, to be emulated)
     \item Argument \texttt{lambda} may now be a \texttt{function(x,y,z)}
       so that an
       inhomogeneous Poisson process may be simulated.
     \item New argument \texttt{lmax}.
     \end{itemize}
	

   \item \texttt{rpoisppx}:
   	New argument \code{drop}.
	
   \item \texttt{rpoisline}:
     Also returns information about the original infinite random lines.

   \item \texttt{rpoislpp}:
     If \texttt{lambda} is a list of \texttt{"linim"} or \texttt{"linfun"}
     objects, then the argument \texttt{L} can be omitted.

   \item \texttt{rPoissonCluster}:
    Argument \texttt{lmax} has been replaced by \texttt{kappamax}.
    
   \item \texttt{rshift.ppp}, \texttt{rshift.splitppp}: 
     new argument \texttt{nsim}.
     
   \item \texttt{rSSI}: 
     \begin{itemize}
     \item Now supports three-dimensional random point patterns.
    Argument \texttt{win} can be a window (class \texttt{owin})
    or a three-dimensional box (class \texttt{box3}).
     \item Accelerated.
     \item New argument \texttt{verbose} specifies whether to
       print progress reports when \texttt{nsim > 1}.
     \end{itemize}
     
 \item \texttt{rStrauss, rHardcore, rStraussHard, rDiggleGratton, rDGS, rPenttinen:}
   New argument \texttt{drop}.

   \item \texttt{rtemper:} new argument \texttt{track}.
     
   \item \texttt{rthin}
   \begin{itemize}
      \item	
      Accelerated, when \texttt{P} is a single number.
      \item
       \texttt{X} can now be a point pattern of any type
       (\texttt{ppp}, \texttt{lpp}, \texttt{pp3}, 
       \texttt{ppx}) or a line segment pattern (\texttt{psp}).
     \end{itemize}

   \item \texttt{rThomas, rMatClust, rCauchy, rVarGamma}:
     \begin{itemize}
     \item New arguments \texttt{n.cond} and \texttt{w.cond}
       specify conditional simulation. Every realisation will have
       exactly \texttt{n.cond} points in total, 
       or exactly \texttt{n.cond} points inside window \texttt{w.cond}
       if it is given.
     \item 
       These algorithms have been accelerated by several orders of magnitude
       in the case where the cluster radius is large.
     \item 
       These functions now offer a choice of simulation algorithms.
    \item 
      Formal arguments have changed. 
     \item 
       When the model is approximately Poisson, it is simulated using rpoispp. 
       This avoids computations which would require huge amounts of memory. 
       New argument \texttt{poisthresh} controls this behaviour.
     \item 
       New argument \texttt{saveparents}.
     \item 
       New arguments \texttt{n.cond} and \texttt{w.cond} specify 
       conditional simulation. Every realisation will have exactly 
       \texttt{n = n.cond} points,
       or exactly \texttt{n.cond} points inside window \texttt{w.cond}
       if it is given.
     \end{itemize}

     
   \item \texttt{runiflpp}, \texttt{rpoislpp}:
     The simulation parameters can be determined from an example
    point pattern, given as the argument \texttt{ex}.

   \item \texttt{runifpoint}:
    New argument \texttt{fail.action} specifies what to do
    if the required number of
    random points cannot be generated. 

   \item \texttt{runifpointOnLines}, \texttt{rpoisppOnLines}:
   	New argument \code{drop}.
     
   \item \texttt{runifpoint3}:
     New argument \texttt{ex} (example point pattern, to be emulated)
	
   \item \texttt{runifpointx}:
   	New argument \code{drop}.
	
%%S   
        
      \item \texttt{selfcut.psp}:
        \begin{itemize}
        \item Computation accelerated.
        \item The result now has an attribute \texttt{"camefrom"}
          indicating the provenance of each segment in the result.
        \item No longer checks for validity of the resulting segments.
        \end{itemize}
        
      \item \texttt{sessionInfo}: 
        Output now includes a list of packages that are imported but not loaded.
        
      \item \texttt{sessionLibs}: 
        Package names are now sorted alphabetically
        
  \item \texttt{setcov}: the name of the unit of length is preserved.

    
  \item \texttt{setminus.owin}: new argument \texttt{rescue}.
    
   \item \code{shapley}:
    In this installed dataset, the function \code{shapley.extra\$plotit}
    has changed slightly (to accommodate the
    dependence on the package \pkg{spatstat.utils}).

  \item \texttt{shift.im}, \texttt{shift.owin},
    \texttt{shift.ppp}, \texttt{shift.psp}:
    More options for the argument \texttt{origin}.
    
  \item Simulation:
   Several basic simulation algorithms have been accelerated.
   Consequently, simulation outcomes are not identical to 
   those obtained with previous versions of \spst, even when the
   same random seed is used. To ensure compatibility with previous
   versions of spatstat, revert to the slower code by setting
   \texttt{spatstat.options(fastthin=FALSE, fastpois=FALSE)}.

   \item \texttt{simulate.kppm}:
     \begin{itemize}
     \item
       For log-Gaussian Cox process models (\texttt{clusters="LGCP"})
       the simulation algorithm has been completely re-implemented
       without using the package \pkg{RandomFields}.
       The current code supports the \texttt{"exponential"}, 
       \texttt{"gauss"}, \texttt{"stable"},
       \texttt{"gencauchy"} and \texttt{"matern"} covariance models.
     \item Conditional simulation of the model, 
       given a fixed number of points,
       is now supported using the new arguments \texttt{n.cond}
       and \texttt{w.cond}.
     \item 
     Additional arguments \verb!...! are now passed to
    the function that performs the simulation.
     \end{itemize}

      \item \texttt{simulate.ppm}:
     \begin{itemize}
     \item  New argument \texttt{newdata} provides support for simulating
    a fitted model in a different window.
     \item 
   New argument \texttt{w} controls the window of the simulated patterns.
     \item 
   New argument \texttt{verbose}.
     \item 
       Now recognises the argument \texttt{window} as an alternative to 
       \texttt{w}.
     \end{itemize}
   
     
   \item \texttt{slrm}:
     \begin{itemize}
     \item New argument \texttt{ruleAtPoints}
       controls discretisation rule at data points.
     \item Arguments \texttt{"..."} are now passed to 
       \texttt{owin2mask} to determine the
       polygon-to-raster discretisation rule for a covariate of class 
       \texttt{owin}.
     \item In the default case (where \texttt{dataAtPoints} is not given)
    all spatial covariates, 
    including the spatial coordinates \texttt{x} and \texttt{y},
    are now evaluated at the centre of each pixel. This improves
    consistency with other implementations of spatial logistic regression.
  \item 
    Silently ignores any arguments \verb!'...'! 
    that are not recognised by \texttt{as.mask}
     \end{itemize}
     
 \item \texttt{Smooth.ppp}:
   \begin{itemize}
   \item Now accepts argument \texttt{rule.pix} passed to \texttt{owin2mask}.
   \item Shrinkage estimate implemented. New arguments
     \texttt{shrink} and \texttt{shrinktype}.
   \item Slight change to algorithms for handling very small bandwidths.
   \item A non-Gaussian kernel can now be specified
   using the argument \texttt{kernel}.
   \item Argument \texttt{weights} can now be a pixel image, a function,
     a numeric vector or an expression to be evaluated.
   \item Infinite bandwidth \texttt{sigma=Inf} is supported.
   \item Accelerated by about 30\% in the case where \texttt{at="pixels"}.
   \item Accelerated by about 15\% in the case where \texttt{at="points"}
     and \texttt{kernel="gaussian"}.
   \item Now exits gracefully if any mark values are \texttt{NA}, \texttt{NaN}
     or \texttt{Inf}.
   \item New argument \texttt{geometric} supports geometric-mean smoothing.
   \item The arguments \texttt{adjust}, \texttt{edge}, \texttt{diggle}
     and \texttt{kernel}
     are now explicit formal arguments.
   \item     Standard error calculation is now supported (Experimental).
   \end{itemize}

 \item \texttt{solapply}:  If an entry of the list is an 
   \texttt{NAobject}, the result for that entry will be an \texttt{NAobject}.
   
 \item \texttt{solist}:
   New argument \verb!.NameBase!

 \item \texttt{spatialcdf}: 
   \begin{itemize}
   \item 
   Computation accelerated.
   \item 
     The result does not inherit class \texttt{"ecdf"} if
     \texttt{normalise=FALSE}.
   \end{itemize}
   
   \item \texttt{spatstat.options}
   New options \texttt{fastthin} and \texttt{fastpois} 
   enable fast simulation algorithms.
   Set these options to \texttt{FALSE} to reproduce results obtained with
   previous versions of \spst.

   \item \texttt{split.ppp}, \texttt{split.ppx}:
   The splitting variable \texttt{f} can now be a logical vector.

   \item \verb!split<-.ppp!:
     The default for argument \texttt{un} in \verb!split<-.ppp!
     now agrees with the default for the same argument in \texttt{split.ppp}.

   \item \texttt{square}: 
     Handles a common error in the format of the arguments.
     
   \item \texttt{step}: now works for models of class \texttt{"mppm"}.

   \item \texttt{stieltjes}:
    Argument \texttt{M} can be a stepfun object (such as an empirical CDF).

  \item \texttt{subset.ppp}, \texttt{subset.lpp}, \texttt{subset.pp3}, 
     \texttt{subset.ppx}:
    The argument \texttt{subset} can now be any argument acceptable to
    the \verb!"["! method.

  \item \texttt{Summary.linim} (methods for the operations \texttt{range}, \texttt{max},
    \texttt{min} etc):
     Recognises the argument \texttt{finite} so that 
     \texttt{range(x, finite=TRUE)} works for a linim object \texttt{x}.
    
  \item summary functions:
    The argument \texttt{correction="all"} is now recognised: it selects
    all the available options. 
    \begin{quote}
        This applies to
        \texttt{Fest}, \texttt{F3est}, \texttt{Gest}, 
        \texttt{Gcross}, \texttt{Gdot}, \texttt{Gmulti}, \texttt{G3est},
        \texttt{Gfox}, \texttt{Hest}, 
        \texttt{Jest}, \texttt{Jmulti}, \texttt{Jcross}, \texttt{Jdot}, 
        \texttt{Jfox}, \texttt{Kest}, \texttt{Kinhom},
        \texttt{Kmulti}, \texttt{Kcross}, \texttt{Kdot}, 
	\texttt{Kmulti.inhom}, \texttt{Kcross.inhom}, 
        \texttt{Kdot.inhom}, \texttt{Kscaled}, \texttt{Ksector}, 
        \texttt{Kmark}, \texttt{K3est}, \texttt{Lscaled}, \texttt{markcorr}, 
        \texttt{markcrosscorr},
	\texttt{nnorient}, \texttt{pairorient}, \texttt{pcfinhom}, 
        \texttt{pcfcross.inhom}, \texttt{pcfcross}, \texttt{pcf}, 
        \texttt{Tstat}.
    \end{quote}

  \item summary functions:
    The following functions have a new argument \texttt{rmax}:
    \begin{quote}
        \texttt{Fest}, \texttt{Finhom}, \texttt{FmultiInhom}, 
        \texttt{Gcross}, \texttt{Gdot}, \texttt{Ginhom},
        \texttt{Gmulti}, \texttt{GmultiInhom},
        \texttt{Jest}, \texttt{Jcross}, \texttt{Jdot}, \texttt{Jinhom}, 
        \texttt{Jmulti},
        \texttt{Kcross}, \texttt{Kdot}, \texttt{Kinhom}, \texttt{Kmulti}, 
	\texttt{Kcross.inhom}, \texttt{Kdot.inhom}, \texttt{Kmulti.inhom}, 
        \texttt{Kmark}, \texttt{Ksector}, 
        \texttt{markconnect}, \texttt{markcorr}, 
        \texttt{markcorrint}, \texttt{markcrosscorr}, \texttt{markequal},
        \texttt{markvario}, \texttt{pcf.ppp}, \texttt{pcfcross}, 
        \texttt{pcfdot}, \texttt{pcfmulti}, \texttt{pcfinhom}
        \texttt{pcfcross.inhom}, \texttt{pcfcross}.
    \end{quote}

   \item \texttt{summary.distfun}, \texttt{summary.funxy}:
     \begin{itemize}
     \item      More information is printed.
     \item Pixel resolution can now be controlled.
     \end{itemize}

   \item \texttt{summary.im}:
     Output improved when the image is empty (i.e. when all pixel values
     are undefined).
     
   \item \texttt{summary.kppm}:
     prints more information about algorithm convergence.
     
   \item \texttt{summary.lintess}:
     prints information about marks.
     
  \item \texttt{summary.lppm}: The name of the original point pattern dataset 
    (to which the model was fitted) is now printed.
    
   \item \texttt{summary.mppm}:
     Improved summary of the dependence of the
    interpoint interaction on the covariates.
     
   \item \texttt{summary.ppm}:
    New argument \texttt{fine} selects the algorithm for variance estimation.

  \item \texttt{summary.slrm}:
    Now prints information about the pixel raster.
    
   \item \texttt{summary.owin}, \texttt{summary.im}:
    The fraction of frame area that is occupied by the window/image
    is now reported.

  \item \texttt{sumouter}:
    \begin{itemize}
    \item New argument \texttt{y} 
      allows computation of asymmetric outer products.
    \item This function has now been moved to the 
      sub-package \texttt{spatstat.sparse}
    \end{itemize}

  
  \item \texttt{symbolmap}:
    \begin{itemize}
    \item 
     Now accepts a vector of colour values for the arguments \texttt{col}, 
     \texttt{cols}, \texttt{fg}, \texttt{bg} if the argument \texttt{range}
     is given.
   \item New option: \texttt{shape="arrows"}.
   \item New arguments \texttt{transform}, \texttt{compress}, 
     \texttt{decompress} for nonlinear symbol maps.
    \end{itemize}


%%T
     
   \item \texttt{tess}:
     \begin{itemize}
     \item A tessellation can now have any kind of marks
    (vector, list, data frame or hyperframe).
     \item Argument \texttt{window} is ignored when xgrid, ygrid are given.
     \end{itemize}


  \item \texttt{texturemap}:
    Argument \texttt{textures} can be missing or NULL.
    
   \item \texttt{textureplot}: 
     Argument \texttt{x} can now be something acceptable to \texttt{as.im}.
   
   \item \texttt{thinNetwork}:
     \texttt{X} can be a pixel image on a network.

    \item \texttt{tileindex}:
      New arguments \texttt{close.gaps} and \texttt{all.inside}.

   \item \texttt{tilenames}, \verb!tilenames<-!:
    These functions are now generic, with methods for \texttt{tess}
    and \texttt{lintess}.

   \item \texttt{to.grey}
   New argument \texttt{transparent}.

   \item \texttt{transect.im}: new argument \texttt{nsample}.
%%U
   
  \item \texttt{union.owin}:
    \begin{itemize}
    \item New argument \texttt{rescue}.
    \item Improved behaviour when there are more than 2 windows.
    \end{itemize}


   
 \item \texttt{uniquemap}:
   handles larger objects.
   
   \item \texttt{unnormdensity}:
     \begin{itemize}
     \item Argument \texttt{bw} may be \texttt{NULL}
       (treated as equivalent to being missing).
     \item  The result has an attribute \texttt{smooth.args}
       containing the smoothing
       parameters that were used in the calculation.
     \item Suppress annoying warning messages from \texttt{density.default}.
           This affects many functions in the \spst\ family of packages.
     \item Argument \texttt{weights} may have length 1.
     \item New argument \texttt{defaults}.
     \item Computation accelerated.
     \end{itemize}

     
   \item \texttt{unstack.lintess}: now handles marks.
     
   \item \texttt{update}: now works for models of class \texttt{"mppm"}.
     
   \item \texttt{update.kppm}:
   \begin{itemize}
   \item New argument \texttt{evaluate}.
   \item Now handles additional arguments in any order, with or without names.
   \item Changed arguments.
   \item Improved behaviour.
   \end{itemize}

   \item \texttt{update.ppm}:
     For the case \texttt{update(model, X)} where \texttt{X} is a point pattern,
    if the window of \texttt{X} is different from the original window,
    then the model is re-fitted from scratch (i.e. \texttt{use.internal=FALSE}).

%%V
   
   \item \texttt{valid.ppm}
   This is now a method for the generic function \texttt{valid}.

   \item \texttt{varcount}:
     \begin{itemize}
     \item 
       Now accepts an object of class \texttt{"clustermodel"}.
     \item 
       New argument \texttt{relative} supports calculation of the 
       overdispersion index. 
     \end{itemize}

   \item \texttt{vcov.mppm}:
     \begin{itemize}
     \item      Now handles models with Gibbs interactions.
     \item New argument \texttt{nacoef.action} specifies what to do
       if some of the fitted coefficients are \texttt{NA}, \texttt{NaN}
       or \texttt{Inf}.
     \end{itemize}



   \item \texttt{vcov.ppm}:
     \begin{itemize}
     \item 
     Performance slightly improved, for Gibbs models.
   \item Variance calculations now handle larger datasets
     because they use sparse arrays, by default.
   \item New argument \texttt{nacoef.action} specifies what to do if
     some of the fitted model coefficients are \texttt{NA}, \texttt{NaN}
     or infinite.
     \end{itemize}

  \item \texttt{Vmark}:
    The result now has an attribute \texttt{smooth.args}
    containing the smoothing parameters used.

     

%%W
     
     
   \item \texttt{with.hyperframe}: 
     If a column in the hyperframe contains \texttt{NAobject} entries,
    and if the name of that column is included in the expression
    being evaluated, then the result of evaluation is an \texttt{NA} or 
    \texttt{NAobject} in the relevant row.
%%X
%%Y
%%Z
   
 \item \verb![<-.hyperframe!:
   \begin{itemize}
   \item In an assignment like \verb!x[i,j] <- NA!, if column \texttt{j}
     contains spatial objects, the \texttt{NA} value will be coerced to an
     \texttt{NAobject} of the appropriate class.
   \item Improved error message when the format of the index is not supported.
   \end{itemize}


     
 \item \verb![<-.im!
   \begin{itemize}
   \item 
  Accepts an array for \texttt{value}.
   \item 
  The subset index \texttt{i} can now be a linear network.
  Then the result of \verb!x[i, drop=FALSE]! is a pixel image of
  class \texttt{linim}.
  \item New argument \texttt{drop} controls behaviour when indices are missing
    as in \verb!x[] <- value!
   \end{itemize}

 \item \verb![.im!
   New argument \texttt{rule.pix} controls the handling of boundary pixels
   in computations like \texttt{x[W]} where \texttt{W} is a polygonal window.

 \item \verb![.layered!:
   \begin{itemize}
   \item 
       Subset index \texttt{i} can now be an \texttt{owin} object.
     \item Additional arguments \verb!...! are now passed to other methods.
   \end{itemize}

       
 \item \verb![.leverage.ppm!:
   New argument \texttt{update}.
       
 \item \verb![.linnet!:
   \begin{itemize}
   \item 
    New argument \texttt{snip} determines what to do with segments 
    of the network that cross the boundary of the window. 
    Default behaviour has changed.
  \item More robust against artefacts when the subset index is a pixel mask.
   \end{itemize}

 \item \verb![.linim!:
   \begin{itemize}
   \item More robust against artefacts.
  \item Accelerated.
   \end{itemize}
    
 \item \verb![.lpp!:
    New argument \texttt{snip} determines what to do with segments 
    of the network that cross the boundary of the window. 
    Default behaviour has changed.

\item \verb![.ppx!:
  \begin{itemize}
  \item 
  The subset index \texttt{i} may now be a spatial domain
  of class \texttt{boxx} or \texttt{box3}.
  \item 
    New argument \texttt{clip}.
  \end{itemize}

   \item \verb![.ppp!:
     \begin{itemize}
     \item 
       New argument \texttt{clip} determines whether the window is clipped.
     \item 
       The previously-unused argument \texttt{drop} now determines whether 
       to remove unused levels of a factor.
     \end{itemize}

   \item \verb![.pp3!, \verb![.lpp!, \verb![.ppx!, 
     \texttt{subset.ppp, subset.pp3, subset.lpp, subset.ppx}:
   These methods now have an argument \texttt{drop} which determines
   whether to remove unused levels of a factor.

   \item \verb![.psp!:
     \begin{itemize}
     \item accelerated.
     \item 
       New argument \texttt{fragments} specifies whether to keep fragments of
       line segments that are cut by the new window, or only to retain
       segments that lie entirely inside the window.
     \end{itemize}

     
 \item \verb![.solist!:
       Subset index \texttt{i} can now be an \texttt{owin} object.

\end{itemize} 

\begin{thebibliography}{1}
\bibitem{badd10wshop}
A.~Baddeley.
\newblock Analysing spatial point patterns in {{R}}.
\newblock Technical report, CSIRO, 2010.
\newblock Version 4.
\newblock URL \texttt{https://research.csiro.au/software/r-workshop-notes/}

\bibitem{baddrubaturn15}
A. Baddeley, E. Rubak, and R. Turner.
\newblock {\em Spatial Point Patterns: Methodology and Applications with {{R}}}.
\newblock Chapman \& Hall/CRC Press, 2015.

\end{thebibliography}
 
\vspace*{\fill}
\noindent
Current total package size: 
\Sexpr{currentcount[["ndatasets"]]} datasets,
\Sexpr{currentcount[["nobjects"]]} functions,
\Sexpr{currentcount[["Rlines"]]} lines of R,
\Sexpr{currentcount[["srclines"]]} lines of C,
\Sexpr{currentcode} total lines of code.

\end{document}
