Come dire quale metodo viene utilizzato da una chiamata di funzione quando `methods` fallisce?

Question

Potrebbe anche lasciare il gatto fuori dalla borsa e dire che ho cercato per circa un giorno di capire cosa sta succedendo quando chiamo plot per un oggetto della classe SpatialPolygons*. Il mio istinto è quello di cercare plot.SpatialPolygonsDataFrame, l'approccio che funziona per qualsiasi numero di altri esempi che ho visto & incontrato, ma questo non è riuscito.

esempio rapida:

US States .shp file qui.

library(maptools) 
us.states<-readShapePoly("cb_2014_us_state_5m.shp") 
plot(us.states) 

Un po 'losca, ma qualsiasi altra cosa - il punto è che una semplice chiamata al plot e da qualche parte in fondo R sapevano quale metodo da chiamare per darci una rappresentazione di tutte le forme.

Dopo aver cercato un po 'intorno, ho provato due degli altri approcci suggeriti da vari SO Q & quanto, prima di tutto:

> methods(plot) 
[1] plot.aareg*       plot.acf*       
[3] plot,ANY,ANY-method     plot.cox.zph*      
[5] plot.data.frame*     plot.decomposed.ts*     
[7] plot.default      plot.dendrogram*     
[9] plot.density*      plot.ecdf       
[11] plot.factor*      plot.formula*      
[13] plot.function      plot.hclust*      
[15] plot.histogram*      plot.HoltWinters*     
[17] plot.isoreg*      plot.lm*       
[19] plot.medpolish*      plot.mlm*       
[21] plot.ppr*       plot.prcomp*      
[23] plot.princomp*      plot.profile.nls*     
[25] plot.raster*      plot.shingle*      
[27] plot,SpatialGrid,missing-method  plot,SpatialLines,missing-method 
[29] plot,Spatial,missing-method   plot,SpatialPixels,missing-method 
[31] plot,SpatialPoints,missing-method plot,SpatialPolygons,missing-method 
[33] plot.spec*       plot.spline*      
[35] plot.stepfun      plot.stl*       
[37] plot.survfit*      plot.table*       
[39] plot.times*       plot.trellis*      
[41] plot.ts        plot.tskernel*      
[43] plot.TukeyHSD*      plot.xyVector*      
[45] plot.zoo*        

La risposta sembrerebbe essere in slot 27-32; tuttavia, ognuno è seguito da una virgola irritante! Non è stato detto che questo è possibile in ?methods e ?plot,SpatialPolygons,missing-method è un errore. Una rapida ricerca di missing-method non restituisce nulla di utile e non c'è ancora alcuna menzione in ?methods.

OK; andare avanti. Che mi dici di getS3method? getMethod? getMethods? getAllMethods ??

> getS3method("plot","SpatialPolygonsDataFrame") 
Error in getS3method("plot", "SpatialPolygonsDataFrame") : 
    S3 method 'plot.SpatialPolygonsDataFrame' not found 

> getMethod("plot","SpatialPolygonsDataFrame") 
Error in getMethod("plot", "SpatialPolygonsDataFrame") : 
    no method found for function 'plot' and signature SpatialPolygonsDataFrame 

Gli ultimi due sono deprecato & anche restituire nulla.

Quindi a quanto pare queste funzioni sono solo una supposizione per il mio primo istinto.

Quindi, adesso? Come posso sapere quale metodo viene chiamato da plot quando viene passato un SpatialPolygonsDataFrame? C'è un approccio generale a questo problema che sostituisce l'approccio che ho usato sopra?

Edit:

sorta di per caso mi sono imbattuto su this (= ?`Spatial-Polygons-class`) che dice:

The plot method for spatial polygons takes the following arguments:

ma ancora non dice che cosa che il metodo è, esattamente.

Answer 1

Per rispondere a un paio di domande sollevate da Gregor. La funzione methods non visualizzava in precedenza i risultati per i metodi S4, ma ora lo fa. Fare una ricerca nel documento NEWS vedo questo è stato aggiunto con la versione 3.2.0:

methods() reports S4 in addition to S3 methods; output is simplified when the class 
argument is used. .S3methods() and methods::.S4methods() report S3 and S4 methods separately. 

SpatialPolygons sono oggetti S4, e così hanno slot e S4-metodi che vengono inviati. È possibile visualizzare un metodo S4 con:

showMethods(f='plot', classes='SpatialPolygons', includeDefs=TRUE) 
# ---- result --- 
Function: plot (package graphics) 
x="SpatialPolygons", y="missing" 
function (x, y, ...) 
plot.SpatialPolygons(x, ...) 

Ciò indica che esiste una funzione S4 per tale classe. È possibile eseguire sp:::SpatialPolygons o getAnywhere(plot.SpatialPolygons) per visualizzare il codice funzione. (Spesso la chiamata usando includeDefs=TRUE mostrerebbe il codice R, ma non qui.) Il risultato per methods(plot) quando il pacchetto 'sp' è caricato indica che ci sono 8 metodi S4 di stampa diversi registrati nello spazio di lavoro. Gli elementi che seguono le virgole sono le "firme" che vengono utilizzate per l'invio delle funzioni. "Metodo mancante" si riferisce a situazioni in cui il secondo argomento non è specificato, in cui la funzione missing eseguita all'interno di un corpo come recuperare TRUE:

[1] plot,ANY,ANY-method     plot,color,ANY-method    
    [3] plot,Spatial,missing-method   plot,SpatialGrid,missing-method  
    [5] plot,SpatialLines,missing-method plot,SpatialPixels,missing-method 
    [7] plot,SpatialPoints,missing-method plot,SpatialPolygons,missing-method 

Questo vi mostrerà ciò che viene quindi utilizzato per inviare un plot -call quando il l'oggetto passato ad esso non corrisponde a nessuno dei metodi S4:

showMethods(f='plot', classes='ANY', includeDefs=TRUE) 
Function: plot (package graphics) 
x="ANY", y="ANY" 
function (x, y, ...) 
UseMethod("plot") 


x="color", y="ANY" 
function (x, y, ...) 
{ 
    .local <- function (x, y, pch = 20, cex = 3) 
    pairs(coords(x), col = hex(x, fix = TRUE), pch = pch, cex = cex) 
    .local(x, y, ...) 
} 

fondamentalmente la R interprete primi controlli per vedere se i metodi S4 sono appropriati, e in mancanza di questo, inizierà passando per i metodi S3 fino arriva a plot.default.

> getMethod(f='plot', signature=c(x='SpatialPolygons', y='missing')) 
Method Definition: 

function (x, y, ...) 
plot.SpatialPolygons(x, ...) 
<environment: namespace:sp> 

Signatures: 
     x     y   
target "SpatialPolygons" "missing" 
defined "SpatialPolygons" "missing" 

E BTW vedo questo nella risposta da ?getMethods:

## Deprecated in 2010 and defunct in 2015 for \code{table = FALSE}: 
getMethods(f, where, table = FALSE) 

Answer 2

Risposta parziale: il metodo è sp:::plot.SpatialPolygons. Non ho idea del motivo per cui queste virgole vengono visualizzate nei risultati di methods(plot); plot,SpatialPolygons,missing-method non ha senso per me (e lo vedo anche io).

Ho trovato la risposta causando un errore. Non ho il tuo file di forma, quindi ho preso l'esempio da help("SpatialPolygonsDataFrame-class"), che ho ottenuto da ?SpatialPolygons".L'esempio è qui sotto:

Sr1 = Polygon(cbind(c(2,4,4,1,2),c(2,3,5,4,2))) 
Sr2 = Polygon(cbind(c(5,4,2,5),c(2,3,2,2))) 
Sr3 = Polygon(cbind(c(4,4,5,10,4),c(5,3,2,5,5))) 
Sr4 = Polygon(cbind(c(5,6,6,5,5),c(4,4,3,3,4)), hole = TRUE) 
Srs1 = Polygons(list(Sr1), "s1") 
Srs2 = Polygons(list(Sr2), "s2") 
Srs3 = Polygons(list(Sr3, Sr4), "s3/4") 
SpP = SpatialPolygons(list(Srs1,Srs2,Srs3), 1:3) 
plot(SpP, col = 1:3, pbg="white") 

Ho poi cambiato la chiamata complotto per dare un errore:

plot(SpP, col = kasjdhfkjasdfhkas, pbg = "white") 
# Error in plot.SpatialPolygons(x, ...) : object 'kasjdhfkjasdfhkas' not found 

(dovrebbe funzionare se non si dispone kasjdhfkjasdfhkas definito nello spazio di lavoro come un vettore). Abbastanza sicuro,

sp:::plot.SpatialPolygons 

ha mostrato il codice per il metodo.