\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.76 $ $Date: 2024/11/18 08:18:36 $

\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"))
sversion <- as.character(x[,"Version"])
sdate    <- as.character(x[,"Date"])
options(useFancyQuotes=FALSE)
@ 

\title{Summary of recent updates to \spst}
\author{Adrian Baddeley, Rolf Turner and Ege Rubak}
\date{\today}
\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)
  ver <- sizetable$version
  isdevel <- sapply(ver, function(x) { length(unlist(package_version(x))) > 3 })
  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=FALSE) {
  #' 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"]] + 1  # counting rule doesn't detect redwood3
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) {
  yvals <- eval(as.expression(fmla[[2]]), envir=dat)
  plot(fmla, ..., data=dat, type="l", xlab="", lwd=2, ylim=c(0, max(yvals)))
}
@ 
\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")
lines(srclines/1000 ~ date, data=z)
text(as.Date("2015-01-01"), 9.5, "C code")
text(as.Date("2015-01-01"), 60, "R code")
@ 
}

\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=FALSE) {
  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, 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{Precis of all changes}

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

\begin{itemize}

  \item New package \pkg{spatstat.univar}.

  \item Some functions from \pkg{spatstat.geom}, \pkg{spatstat.random}
    and \pkg{spatstat.explore} have been moved to \pkg{spatstat.univar}.
    
  \item packages \pkg{spatstat.geom}, \pkg{spatstat.random}
    and \pkg{spatstat.explore} now depend on \pkg{spatstat.univar}.

  \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.
\end{itemize}

\section{New classes}

The following new classes of objects may be of use.

\begin{itemize}
\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{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 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.im}: Many methods for \texttt{as.im}
    now have argument \texttt{rule.eps}.

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

  \item \texttt{as.im.tess}:
  New argument \texttt{values}.

  \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.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 
      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}:
    New argument \texttt{varcov1} for anisotropic bandwidth selection.

  \item \texttt{bw.stoyan}: 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.
    
%%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}:
    The polygon is now drawn progressively as the user clicks new vertices.

 \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{colourmap}: argument \texttt{col} have have length 1,
  representing a trivial colour map in which all data values are
  mapped to the same colour.
  
\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}:    
    Arguments \texttt{...} now determine pixel resolution.

  \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{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{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{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 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 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 \texttt{diagnose.ppm}:
    \begin{itemize}
    \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{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{distmap.owin}:
   \begin{itemize}
   \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}:
   New argument \texttt{clip}.

 \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{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 
    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{envelope}:
   \begin{itemize}
   \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 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{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}:
   Additional checks for errors in input data.

 \item \texttt{Finhom}:
   \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{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   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{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}: 
   Function labels (shown on the plot legend) have been improved when 
   \texttt{i = j}.
   
  \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}:
     The result belongs to classes \texttt{solist} and \texttt{imlist}
     so that it can be plotted.
     
 \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 
   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}
   
%%I
 \item \texttt{identify.ppp}: 
   Automatically starts a new plot device if none is open.

   \item \texttt{identify.psp}: 
   \begin{itemize}
   \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 Computation accelerated
    \item New argument \texttt{fun.handles.na}
    \item New argument \texttt{check}
    \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{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 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.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.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 
    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 
     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{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}
   Argument \texttt{lambdaI=NULL} or \texttt{lambdadot=NULL} 
   is now interpreted to mean
   that the intensity should be estimated by kernel smoothing.
   
 \item \texttt{linearKcross.inhom}, \texttt{linearpcfcross.inhom}
   Argument \texttt{lambdaI=NULL} or \texttt{lambdaJ=NULL} 
   is now interpreted to mean
   that the intensity should be estimated by kernel smoothing.
   
 \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{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 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.ppm}: accelerated.
  
\item \texttt{lut}: argument \texttt{outputs} may have length 1, 
  representing a lookup table in which all data values are mapped
  to the same output value.
  
%%M
   
 \item \texttt{markconnect}:
   Accepts the argument \texttt{weights} which is passed to \texttt{markcorr}.

 \item \texttt{markcorr}:
   \begin{itemize}
   \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.
   \item 
     Now allows negative mark values, when \texttt{normalise=FALSE}.
   \end{itemize}

\item \texttt{markcrosscorr}:
       Now allows negative mark values, when \texttt{normalise=FALSE}.
   
 \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}:
   Accepts the argument \texttt{weights} which is passed to \texttt{markcorr}.

 \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 
     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.
    
%%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.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 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.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{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}:
    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.
    
%%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
	New argument \code{close} for advanced use.
   \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}, \texttt{pcfmulti}:
   New argument \texttt{ratio} makes it possible to save the numerator and
   denominator of the function estimates, so that estimates can be pooled.
    
 \item \texttt{pcfcross.inhom}, \texttt{pcfdor.inhom}:
   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 \texttt{pcfinhom}:
   \begin{itemize}
   \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 \code{persp.funxy}:
   Improved $z$-axis label.
   
  \item \texttt{pixellate.ppp}:
    \begin{itemize}
    \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{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 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.
   \end{itemize}

 \item \texttt{plot.fv}:
   New argument \texttt{clip.xlim}.
   
 \item \texttt{plot.im}:
   \begin{itemize}
   \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}.
   \end{itemize}

 \item \texttt{plot.imlist}:
   Result is now an (invisible) list containing the result
   from executing the plot of each panel.

 \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.
     \end{itemize}
     
  \item \texttt{plot.profilepl}:
        This function has now been documented, and the graphics improved.
        
  \item \texttt{plot.psp}:
    \begin{itemize}
    \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.
    \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  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 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{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 \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{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}: Output includes information about marks.

  \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{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 \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}

%%Q

    
  \item \texttt{quadform}: This function has been moved
    to the sub-package \texttt{spatstat.sparse}.
    
 \item \texttt{quadratcount.ppp}:
   Computation accelerated in some cases.

 \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{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{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}
     
   \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 
         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}.
       \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{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{rNeymanScott}:
    \begin{itemize}
    \item Argument \texttt{lmax} has been replaced by \texttt{kappamax}.
    \item New argument 'mumax'.    
    \end{itemize}

 \item \texttt{rose.default}
   New argument \texttt{weights}.

   \item \texttt{rose}
   New arguments \texttt{start} and \texttt{clockwise} specify the convention
   for measuring and plotting angles.

 \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}:
      New argument \texttt{forcewin} forces the code to use the window 
      \texttt{win} when \texttt{f} is a pixel image.
    
   \item \texttt{rpoispp}:
   Accelerated, when \texttt{lambda} is a pixel image.

   \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 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 
       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}.
     \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{runifpointOnLines}, \texttt{rpoisppOnLines}:
   	New argument \code{drop}.
     
   \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 \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{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 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 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{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{Gcom}, \texttt{Gres}, \texttt{Hest}, 
        \texttt{Jest}, \texttt{Jmulti}, \texttt{Jcross}, \texttt{Jdot}, 
        \texttt{Jfox}, \texttt{Kest}, \texttt{Kinhom},
        \texttt{Kmulti}, \texttt{Kcross}, \texttt{Kdot}, \texttt{Kcom}, 
        \texttt{Kres}, 
	\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 \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.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"}.
    \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{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}:
   Improved behaviour when there are more than 2 windows.

   \item \texttt{unnormdensity}:
     \begin{itemize}
     \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}:
     New argument \texttt{relative} supports calculation of the 
     overdispersion index. 

   \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}


%%W
%%X
%%Y
%%Z
   
 \item \verb![<-.hyperframe!:
   Improved error message when the format of the index is not supported.
     
 \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![.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}
