alltypes              package:spatstat              R Documentation

_C_a_l_c_u_l_a_t_e _S_t_a_t_i_s_t_i_c _f_o_r _A_l_l _T_y_p_e_s _i_n _a _M_u_l_t_i_t_y_p_e _P_o_i_n_t _P_a_t_t_e_r_n

_D_e_s_c_r_i_p_t_i_o_n:

     Given a marked point pattern, this computes the estimates of a
     selected summary function (F,G, J or K) of the pattern, for all
     possible combinations of marks. It returns these functions in a
     list (an object of class '"fasp"') amenable to plotting by
     'plot.fasp()'.

_U_s_a_g_e:

       alltypes(pp, fun="K",dataname=NULL,verb=FALSE)

_A_r_g_u_m_e_n_t_s:

      pp: The observed point pattern, for which summary function
          estimates are required.  An object of class '"ppp"'. If the
          pattern is not marked, the resulting ``array'' has dimensions
          1 x 1. 

     fun: Character string indicating the summary function required. 
          Options are '"F"', '"G"', '"J"', '"K"', '"Gcross"',
          '"Jcross"', '"Kcross"', '"Gdot"', '"Jdot"', '"Kdot"'. 

dataname: Character string giving an optional (alternative) name to the
          point pattern, different from what is given in the call. 
          This name, if supplied, may be used by 'plot.fasp()' in
          forming the title of the plot. If not supplied it defaults to
          the parsing of the argument supplied as 'pp' in the call. 

    verb: Logical value, meaning ``verbose''.  If verb is true then
          terse ``progress reports'' (just the values of the mark
          indices) are printed out when the calculations for that
          combination of marks are completed.  

_D_e_t_a_i_l_s:

     This routine is a convenient way to analyse the dependence between
     types in a multitype point pattern. Suppose that the points have
     possible types 1,2,...,m and let X[i] denote the pattern of points
     of type i only.

     If 'fun="F"' then this routine calculates, for each possible type
     i, an estimate of the Empty Space Function F_i(r) of X[i]. See
     'Fest' for explanation of the empty space function.

     If 'fun' is '"Gcross"', '"Jcross"' or '"Kcross"', the routine
     calculates, for each pair of types (i,j), an estimate of the
     ``'i'-to'j''' cross-type function G[i,j](r), J[i,j](r) or
     K[i,j](r) respectively describing the dependence between  X[i] and
     X[j]. See 'Gcross', 'Jcross' or 'Kcross' respectively for
     explanation of these functions.

     If 'fun' is  '"Gdot"', '"Jdot"' or '"Kdot"', the routine
     calculates, for each type i, an estimate of the ``'i'-to-any''
     dot-type function G[i.](r), J[i.](r) or K[i.](r) respectively
     describing the dependence between X[i] and X. See 'Gdot', 'Jdot'
     or 'Kdot' respectively for explanation of these functions.

     The letters '"G"', '"J"' and '"K"' are interpreted as
     abbreviations for '"Gcross"', '"Jcross"' and '"Kcross"'
     respectively, assumin the point pattern is marked. If the point
     pattern is unmarked, the appropriate function 'Fest', 'Jest' or
     'Kest' is invoked instead.

_V_a_l_u_e:

     A function array (an object of class '"fasp"', see 'fasp.object').
     This can be plotted using 'plot.fasp'.

     If 'fun="F"', the function array has dimensions m * 1 where m is
     the number of different marks in the point pattern. The entry at
     position '[i,1]' in this array is the result of applying 'Fest' to
     the points of type 'i' only.

     If 'fun' is '"Gdot"', '"Jdot"' or '"Kdot"', the function array
     again has dimensions m * 1. The entry at position '[i,1]' in this
     array is the result of 'Gdot(pp, i)' or 'Jdot(pp, i)' or 'Kdot(pp,
     i)' respectively.

     If 'fun' is '"Gcross"', '"Jcross"' or '"Kcross"', (or their
     abbreviations '"G"', '"J"' or '"K"'), the function array has
     dimensions m * m. The '[i,j]' entry of the function array (for i
     != j) is the result of applying the function 'Gcross', 'Jcross' or
     'Kcross' to the pair of types '(i,j)'. The diagonal '[i,i]' entry
     of the function array is the result of applying the univariate
     function 'Gest', 'Jest' or 'Kest' to the points of type 'i' only.

     Each function entry 'fns[[i]]' retains the format of the output of
     the relevant estimating routine 'Fest', 'Gest', 'Jest', 'Kest', 
     'Gcross', 'Jcross', 'Kcross', 'Gdot', 'Jdot', or 'Kdot'.

     The default formulae for plotting these functions are 
     'cbind(km,theo) ~ r' for F, G, and J functions, and
     'cbind(trans,theo) ~ r' for K functions.

_N_o_t_e:

     Sizeable amounts of memory may be needed during the calculation.

_A_u_t_h_o_r(_s):

     Adrian Baddeley adrian@maths.uwa.edu.au <URL:
     http://www.maths.uwa.edu.au/~adrian/> and Rolf Turner
     rolf@math.unb.ca <URL: http://www.math.unb.ca/~rolf>

_S_e_e _A_l_s_o:

     'plot.fasp', 'fasp.object', 'allstats', 'Fest', 'Gest', 'Jest',
     'Kest', 'Gcross', 'Jcross', 'Kcross', 'Gdot', 'Jdot', 'Kdot'

_E_x_a_m_p_l_e_s:

        # bramblecanes (3 marks).
        data(bramblecanes)
        ## Not run: 
        X.F <- alltypes(bramblecanes,fun="F",verb=TRUE)
        plot(X.F) 
        X.G <- alltypes(bramblecanes,fun="G",verb=TRUE)
        X.J <- alltypes(bramblecanes,fun="J",verb=TRUE)
        X.K <- alltypes(bramblecanes,fun="K",verb=TRUE)
        X.Gd <- alltypes(bramblecanes,fun="Gdot",verb=TRUE)
        X.Jd <- alltypes(bramblecanes,fun="Jdot",verb=TRUE)
        X.Kd <- alltypes(bramblecanes,fun="Kdot",verb=TRUE)
        
     ## End(Not run)
        
        
        # Swedishpines (unmarked).
        data(swedishpines)
        
        X.K <- alltypes(swedishpines,fun="K")
        X.F <- alltypes(swedishpines,fun="F")
        X.G <- alltypes(swedishpines,fun="G")
        X.J <- alltypes(swedishpines,fun="J")

        # simulated data
        ## Not run: 
        pp <- runifpoint(350, owin(c(0,1),c(0,1)))
        pp$marks <- factor(c(rep(1,50),rep(2,100),rep(3,200)))
        X.F <- alltypes(pp,fun="F",verb=TRUE,dataname="Fake Data")
        X.G <- alltypes(pp,fun="G",verb=TRUE,dataname="Fake Data")
        X.J <- alltypes(pp,fun="J",verb=TRUE,dataname="Fake Data")
        X.K <- alltypes(pp,fun="K",verb=TRUE,dataname="Fake Data")
        
     ## End(Not run)

        # A setting where you might REALLY want to use dataname:
        ## Not run: 
        xxx <- alltypes(ppp(Melvin$x,Melvin$y,
                     window=as.owin(c(5,20,15,50)),marks=clyde),
                     fun="F",verb=TRUE,dataname="Melvin")
        
     ## End(Not run)

