Jak dodać teksturę, aby wypełnić kolory w ggplot2

103

Obecnie używam scale_brewer()do wypełnienia i wyglądają pięknie w kolorze (na ekranie i na drukarce kolorowej), ale drukują stosunkowo jednolicie jako szarości, gdy używam drukarki czarno-białej. Przeszukałem ggplot2dokumentację online, ale nie znalazłem nic o dodawaniu tekstur w celu wypełnienia kolorów. Czy istnieje oficjalny ggplot2sposób na zrobienie tego lub czy ktoś ma hack, którego używa? Przez tekstury mam na myśli takie rzeczy, jak ukośne paski, odwrócone ukośne paski, wzory kropek itp., Które rozróżniają kolory wypełnienia po wydrukowaniu w czerni i bieli.

rhh
źródło

Odpowiedzi:

35

ggplot może używać palet colorbrewer. Niektóre z nich są przyjazne dla „kserokopii”. Więc czy coś takiego zadziała dla Ciebie?

ggplot(diamonds, aes(x=cut, y=price, group=cut))+
geom_boxplot(aes(fill=cut))+scale_fill_brewer(palette="OrRd")

w tym przypadku OrRd to paleta znaleziona na stronie colorbrewer: http://colorbrewer2.org/

Przyjazny dla kserokopii: Oznacza to, że dany schemat kolorów wytrzyma kopiowanie czarno-białe. Nie można pomyślnie kopiować rozbieżnych schematów. Różnice w jasności należy zachować za pomocą schematów sekwencyjnych.

Andreas
źródło
23
Nie odpowiada na pytanie PO. Przyjechałem tutaj, ponieważ utknąłem w pewnych kolorach. Ta zaakceptowana „odpowiedź” nie sugeruje, jak stosować tekstury.
MS Berends
3
@MSBerends to nie odpowiada na twoje pytanie . Jestem prawie pewien, że zielony znacznik wyboru to znak, że odpowiedział na pytanie!
Yan Foto
10
Nie daj się zwieść znacznikowi wyboru. Pytanie brzmiało, jak zastosować tekstury - i na to nie ma odpowiedzi. Przedstawiono pomysł nieszablonowy, tak, ale bez odpowiedzi na pytanie.
MS Berends
84

Hej, ludzie, oto mały hack, który rozwiązuje problem tekstury w bardzo prosty sposób:

ggplot2: spraw, aby obramowanie jednego paska było ciemniejsze niż inne, używając R.

EDYCJA: Wreszcie znalazłem czas, aby podać krótki przykład tego hacka, który pozwala na co najmniej 3 typy podstawowego wzorca w ggplot2. Kod:

Example.Data<- data.frame(matrix(vector(), 0, 3, dimnames=list(c(), c("Value", "Variable", "Fill"))), stringsAsFactors=F)

Example.Data[1, ] <- c(45, 'Horizontal Pattern','Horizontal Pattern' )
Example.Data[2, ] <- c(65, 'Vertical Pattern','Vertical Pattern' )
Example.Data[3, ] <- c(89, 'Mesh Pattern','Mesh Pattern' )


HighlightDataVert<-Example.Data[2, ]
HighlightHorizontal<-Example.Data[1, ]
HighlightMesh<-Example.Data[3, ]
HighlightHorizontal$Value<-as.numeric(HighlightHorizontal$Value)
Example.Data$Value<-as.numeric(Example.Data$Value)

HighlightDataVert$Value<-as.numeric(HighlightDataVert$Value)
HighlightMesh$Value<-as.numeric(HighlightMesh$Value)
HighlightHorizontal$Value<-HighlightHorizontal$Value-5
HighlightHorizontal2<-HighlightHorizontal
HighlightHorizontal2$Value<-HighlightHorizontal$Value-5
HighlightHorizontal3<-HighlightHorizontal2
HighlightHorizontal3$Value<-HighlightHorizontal2$Value-5
HighlightHorizontal4<-HighlightHorizontal3
HighlightHorizontal4$Value<-HighlightHorizontal3$Value-5
HighlightHorizontal5<-HighlightHorizontal4
HighlightHorizontal5$Value<-HighlightHorizontal4$Value-5
HighlightHorizontal6<-HighlightHorizontal5
HighlightHorizontal6$Value<-HighlightHorizontal5$Value-5
HighlightHorizontal7<-HighlightHorizontal6
HighlightHorizontal7$Value<-HighlightHorizontal6$Value-5
HighlightHorizontal8<-HighlightHorizontal7
HighlightHorizontal8$Value<-HighlightHorizontal7$Value-5

HighlightMeshHoriz<-HighlightMesh
HighlightMeshHoriz$Value<-HighlightMeshHoriz$Value-5
HighlightMeshHoriz2<-HighlightMeshHoriz
HighlightMeshHoriz2$Value<-HighlightMeshHoriz2$Value-5
HighlightMeshHoriz3<-HighlightMeshHoriz2
HighlightMeshHoriz3$Value<-HighlightMeshHoriz3$Value-5
HighlightMeshHoriz4<-HighlightMeshHoriz3
HighlightMeshHoriz4$Value<-HighlightMeshHoriz4$Value-5
HighlightMeshHoriz5<-HighlightMeshHoriz4
HighlightMeshHoriz5$Value<-HighlightMeshHoriz5$Value-5
HighlightMeshHoriz6<-HighlightMeshHoriz5
HighlightMeshHoriz6$Value<-HighlightMeshHoriz6$Value-5
HighlightMeshHoriz7<-HighlightMeshHoriz6
HighlightMeshHoriz7$Value<-HighlightMeshHoriz7$Value-5
HighlightMeshHoriz8<-HighlightMeshHoriz7
HighlightMeshHoriz8$Value<-HighlightMeshHoriz8$Value-5
HighlightMeshHoriz9<-HighlightMeshHoriz8
HighlightMeshHoriz9$Value<-HighlightMeshHoriz9$Value-5
HighlightMeshHoriz10<-HighlightMeshHoriz9
HighlightMeshHoriz10$Value<-HighlightMeshHoriz10$Value-5
HighlightMeshHoriz11<-HighlightMeshHoriz10
HighlightMeshHoriz11$Value<-HighlightMeshHoriz11$Value-5
HighlightMeshHoriz12<-HighlightMeshHoriz11
HighlightMeshHoriz12$Value<-HighlightMeshHoriz12$Value-5
HighlightMeshHoriz13<-HighlightMeshHoriz12
HighlightMeshHoriz13$Value<-HighlightMeshHoriz13$Value-5
HighlightMeshHoriz14<-HighlightMeshHoriz13
HighlightMeshHoriz14$Value<-HighlightMeshHoriz14$Value-5
HighlightMeshHoriz15<-HighlightMeshHoriz14
HighlightMeshHoriz15$Value<-HighlightMeshHoriz15$Value-5
HighlightMeshHoriz16<-HighlightMeshHoriz15
HighlightMeshHoriz16$Value<-HighlightMeshHoriz16$Value-5
HighlightMeshHoriz17<-HighlightMeshHoriz16
HighlightMeshHoriz17$Value<-HighlightMeshHoriz17$Value-5

ggplot(Example.Data, aes(x=Variable, y=Value, fill=Fill)) + theme_bw() + #facet_wrap(~Product, nrow=1)+ #Ensure theme_bw are there to create borders
  theme(legend.position = "none")+
  scale_fill_grey(start=.4)+
  #scale_y_continuous(limits = c(0, 100), breaks = (seq(0,100,by = 10)))+
  geom_bar(position=position_dodge(.9), stat="identity", colour="black", legend = FALSE)+
  geom_bar(data=HighlightDataVert, position=position_dodge(.9), stat="identity", colour="black", size=.5, width=0.80)+
geom_bar(data=HighlightDataVert, position=position_dodge(.9), stat="identity", colour="black", size=.5, width=0.60)+  
  geom_bar(data=HighlightDataVert, position=position_dodge(.9), stat="identity", colour="black", size=.5, width=0.40)+
  geom_bar(data=HighlightDataVert, position=position_dodge(.9), stat="identity", colour="black", size=.5, width=0.20)+
  geom_bar(data=HighlightDataVert, position=position_dodge(.9), stat="identity", colour="black", size=.5, width=0.0) +
  geom_bar(data=HighlightHorizontal, position=position_dodge(.9), stat="identity", colour="black", size=.5)+
  geom_bar(data=HighlightHorizontal2, position=position_dodge(.9), stat="identity", colour="black", size=.5)+
  geom_bar(data=HighlightHorizontal3, position=position_dodge(.9), stat="identity", colour="black", size=.5)+
  geom_bar(data=HighlightHorizontal4, position=position_dodge(.9), stat="identity", colour="black", size=.5)+
  geom_bar(data=HighlightHorizontal5, position=position_dodge(.9), stat="identity", colour="black", size=.5)+
  geom_bar(data=HighlightHorizontal6, position=position_dodge(.9), stat="identity", colour="black", size=.5)+
  geom_bar(data=HighlightHorizontal7, position=position_dodge(.9), stat="identity", colour="black", size=.5)+
  geom_bar(data=HighlightHorizontal8, position=position_dodge(.9), stat="identity", colour="black", size=.5)+
  geom_bar(data=HighlightMesh, position=position_dodge(.9), stat="identity", colour="black", size=.5, width=0.80)+
 geom_bar(data=HighlightMesh, position=position_dodge(.9), stat="identity", colour="black", size=.5, width=0.60)+
  geom_bar(data=HighlightMesh, position=position_dodge(.9), stat="identity", colour="black", size=.5, width=0.40)+
  geom_bar(data=HighlightMesh, position=position_dodge(.9), stat="identity", colour="black", size=.5, width=0.20)+
  geom_bar(data=HighlightMesh, position=position_dodge(.9), stat="identity", colour="black", size=.5, width=0.0)+
  geom_bar(data=HighlightMeshHoriz, position=position_dodge(.9), stat="identity", colour="black", size=.5, fill = "transparent")+
geom_bar(data=HighlightMeshHoriz2, position=position_dodge(.9), stat="identity", colour="black", size=.5, fill = "transparent")+
  geom_bar(data=HighlightMeshHoriz3, position=position_dodge(.9), stat="identity", colour="black", size=.5, fill = "transparent")+
  geom_bar(data=HighlightMeshHoriz4, position=position_dodge(.9), stat="identity", colour="black", size=.5, fill = "transparent")+
  geom_bar(data=HighlightMeshHoriz5, position=position_dodge(.9), stat="identity", colour="black", size=.5, fill = "transparent")+
  geom_bar(data=HighlightMeshHoriz6, position=position_dodge(.9), stat="identity", colour="black", size=.5, fill = "transparent")+
  geom_bar(data=HighlightMeshHoriz7, position=position_dodge(.9), stat="identity", colour="black", size=.5, fill = "transparent")+
  geom_bar(data=HighlightMeshHoriz8, position=position_dodge(.9), stat="identity", colour="black", size=.5, fill = "transparent")+
  geom_bar(data=HighlightMeshHoriz9, position=position_dodge(.9), stat="identity", colour="black", size=.5, fill = "transparent")+
  geom_bar(data=HighlightMeshHoriz10, position=position_dodge(.9), stat="identity", colour="black", size=.5, fill = "transparent")+
  geom_bar(data=HighlightMeshHoriz11, position=position_dodge(.9), stat="identity", colour="black", size=.5, fill = "transparent")+
  geom_bar(data=HighlightMeshHoriz12, position=position_dodge(.9), stat="identity", colour="black", size=.5, fill = "transparent")+
  geom_bar(data=HighlightMeshHoriz13, position=position_dodge(.9), stat="identity", colour="black", size=.5, fill = "transparent")+
  geom_bar(data=HighlightMeshHoriz14, position=position_dodge(.9), stat="identity", colour="black", size=.5, fill = "transparent")+
  geom_bar(data=HighlightMeshHoriz15, position=position_dodge(.9), stat="identity", colour="black", size=.5, fill = "transparent")+
  geom_bar(data=HighlightMeshHoriz16, position=position_dodge(.9), stat="identity", colour="black", size=.5, fill = "transparent")+
  geom_bar(data=HighlightMeshHoriz17, position=position_dodge(.9), stat="identity", colour="black", size=.5, fill = "transparent")

Produkuje to:

wprowadź opis obrazu tutaj

Nie jest super ładne, ale to jedyne rozwiązanie, o którym mogę pomyśleć.

Jak widać, przedstawiam bardzo podstawowe dane. Aby uzyskać pionowe linie, po prostu tworzę ramkę danych zawierającą zmienną, do której chciałem dodać pionowe linie, i wielokrotnie poprawiałem granice wykresu, zmniejszając za każdym razem szerokość.

Podobnie dzieje się z liniami poziomymi, ale dla każdego przerysowania potrzebna jest nowa ramka danych, w której odjęłam wartość (w moim przykładzie „5”) od wartości związanej z interesującą nas zmienną. Skutecznie obniża wysokość drążka. Jest to trudne do osiągnięcia i mogą istnieć bardziej usprawnione podejścia, ale to ilustruje, jak można to osiągnąć.

Wzór siatki jest połączeniem obu. Najpierw wyciągnąć pionowych linii, a następnie dodać linie poziome ustawienie fillw fill='transparent'celu zapewnienia, że pionowe linie nie są narysowane na drugą.

Do czasu aktualizacji wzoru mam nadzieję, że niektórym z was będzie to przydatne.

EDYCJA 2:

Dodatkowo można dodać ukośne wzory. Dodałem dodatkową zmienną do ramki danych:

Example.Data[4,] <- c(20, 'Diagonal Pattern','Diagonal Pattern' )

Następnie utworzyłem nową ramkę danych do przechowywania współrzędnych dla ukośnych linii:

Diag <- data.frame(
  x = c(1,1,1.45,1.45), # 1st 2 values dictate starting point of line. 2nd 2 dictate width. Each whole = one background grid
  y = c(0,0,20,20),
  x2 = c(1.2,1.2,1.45,1.45), # 1st 2 values dictate starting point of line. 2nd 2 dictate width. Each whole = one background grid
  y2 = c(0,0,11.5,11.5),# inner 2 values dictate height of horizontal line. Outer: vertical edge lines.
  x3 = c(1.38,1.38,1.45,1.45), # 1st 2 values dictate starting point of line. 2nd 2 dictate width. Each whole = one background grid
  y3 = c(0,0,3.5,3.5),# inner 2 values dictate height of horizontal line. Outer: vertical edge lines.
  x4 = c(.8,.8,1.26,1.26), # 1st 2 values dictate starting point of line. 2nd 2 dictate width. Each whole = one background grid
  y4 = c(0,0,20,20),# inner 2 values dictate height of horizontal line. Outer: vertical edge lines.
  x5 = c(.6,.6,1.07,1.07), # 1st 2 values dictate starting point of line. 2nd 2 dictate width. Each whole = one background grid
  y5 = c(0,0,20,20),# inner 2 values dictate height of horizontal line. Outer: vertical edge lines.
  x6 = c(.555,.555,.88,.88), # 1st 2 values dictate starting point of line. 2nd 2 dictate width. Each whole = one background grid
  y6 = c(6,6,20,20),# inner 2 values dictate height of horizontal line. Outer: vertical edge lines.
  x7 = c(.555,.555,.72,.72), # 1st 2 values dictate starting point of line. 2nd 2 dictate width. Each whole = one background grid
  y7 = c(13,13,20,20),# inner 2 values dictate height of horizontal line. Outer: vertical edge lines.
  x8 = c(.8,.8,1.26,1.26), # 1st 2 values dictate starting point of line. 2nd 2 dictate width. Each whole = one background grid
  y8 = c(0,0,20,20),# inner 2 values dictate height of horizontal line. Outer: vertical edge lines.
  #Variable = "Diagonal Pattern",
  Fill = "Diagonal Pattern"
  )

Stamtąd dodałem geom_paths do powyższego ggplot, z których każdy wywołuje inne współrzędne i rysuje linie na żądanym pasku:

+geom_path(data=Diag, aes(x=x, y=y),colour = "black")+  # calls co-or for sig. line & draws
  geom_path(data=Diag, aes(x=x2, y=y2),colour = "black")+  # calls co-or for sig. line & draws
  geom_path(data=Diag, aes(x=x3, y=y3),colour = "black")+
  geom_path(data=Diag, aes(x=x4, y=y4),colour = "black")+
  geom_path(data=Diag, aes(x=x5, y=y5),colour = "black")+
  geom_path(data=Diag, aes(x=x6, y=y6),colour = "black")+
  geom_path(data=Diag, aes(x=x7, y=y7),colour = "black")

Skutkuje to:

wprowadź opis obrazu tutaj

Jest trochę niechlujny, ponieważ nie zainwestowałem zbyt wiele czasu w ustawienie linii idealnie pod kątem i rozstawionych, ale powinno to służyć jako dowód koncepcji.

Oczywiście linie mogą przechylać się w przeciwnym kierunku, a ponadto jest miejsce na siatkowanie ukośne, podobnie jak w przypadku siatki poziomej i pionowej.

Myślę, że to wszystko, co mogę zaoferować na froncie wzoru. Mam nadzieję, że ktoś znajdzie dla niego zastosowanie.

EDYCJA 3: Słynne ostatnie słowa. Wymyśliłem inną opcję wzoru. Tym razem za pomocą geom_jitter.

Ponownie dodałem kolejną zmienną do ramki danych:

Example.Data[5,] <- c(100, 'Bubble Pattern','Bubble Pattern' )

I zamówiłem, jak chcę, aby każdy wzór był prezentowany:

Example.Data$Variable = Relevel(Example.Data$Variable, ref = c("Diagonal Pattern", "Bubble Pattern","Horizontal Pattern","Mesh Pattern","Vertical Pattern"))

Następnie utworzyłem kolumnę zawierającą liczbę skojarzoną z zamierzonym słupkiem docelowym na osi x:

Example.Data$Bubbles <- 2

Po nich następują kolumny zawierające pozycje na osi Y „bąbelków”:

Example.Data$Points <- c(5, 10, 15, 20, 25)
Example.Data$Points2 <- c(30, 35, 40, 45, 50)
Example.Data$Points3 <- c(55, 60, 65, 70, 75)
Example.Data$Points4 <- c(80, 85, 90, 95, 7)
Example.Data$Points5 <- c(14, 21, 28, 35, 42)
Example.Data$Points6 <- c(49, 56, 63, 71, 78)
Example.Data$Points7 <- c(84, 91, 98, 6, 12)

Na koniec dodałem geom_jitters do powyższego ggplot, używając nowych kolumn do pozycjonowania i ponownego używania „Punktów”, aby zmieniać rozmiar „bąbelków”:

+geom_jitter(data=Example.Data,aes(x=Bubbles, y=Points, size=Points), alpha=.5)+
  geom_jitter(data=Example.Data,aes(x=Bubbles, y=Points2, size=Points), alpha=.5)+
  geom_jitter(data=Example.Data,aes(x=Bubbles, y=Points, size=Points), alpha=.5)+
  geom_jitter(data=Example.Data,aes(x=Bubbles, y=Points2, size=Points), alpha=.5)+
  geom_jitter(data=Example.Data,aes(x=Bubbles, y=Points3, size=Points), alpha=.5)+
  geom_jitter(data=Example.Data,aes(x=Bubbles, y=Points4, size=Points), alpha=.5)+
  geom_jitter(data=Example.Data,aes(x=Bubbles, y=Points, size=Points), alpha=.5)+
  geom_jitter(data=Example.Data,aes(x=Bubbles, y=Points2, size=Points), alpha=.5)+
  geom_jitter(data=Example.Data,aes(x=Bubbles, y=Points, size=Points), alpha=.5)+
  geom_jitter(data=Example.Data,aes(x=Bubbles, y=Points2, size=Points), alpha=.5)+
  geom_jitter(data=Example.Data,aes(x=Bubbles, y=Points3, size=Points), alpha=.5)+
  geom_jitter(data=Example.Data,aes(x=Bubbles, y=Points4, size=Points), alpha=.5)+
  geom_jitter(data=Example.Data,aes(x=Bubbles, y=Points2, size=Points), alpha=.5)+
  geom_jitter(data=Example.Data,aes(x=Bubbles, y=Points5, size=Points), alpha=.5)+
  geom_jitter(data=Example.Data,aes(x=Bubbles, y=Points5, size=Points), alpha=.5)+
  geom_jitter(data=Example.Data,aes(x=Bubbles, y=Points6, size=Points), alpha=.5)+
  geom_jitter(data=Example.Data,aes(x=Bubbles, y=Points6, size=Points), alpha=.5)+
  geom_jitter(data=Example.Data,aes(x=Bubbles, y=Points7, size=Points), alpha=.5)+
  geom_jitter(data=Example.Data,aes(x=Bubbles, y=Points7, size=Points), alpha=.5)+
  geom_jitter(data=Example.Data,aes(x=Bubbles, y=Points, size=Points), alpha=.5)+
  geom_jitter(data=Example.Data,aes(x=Bubbles, y=Points2, size=Points), alpha=.5)+
  geom_jitter(data=Example.Data,aes(x=Bubbles, y=Points, size=Points), alpha=.5)+
  geom_jitter(data=Example.Data,aes(x=Bubbles, y=Points2, size=Points), alpha=.5)+
  geom_jitter(data=Example.Data,aes(x=Bubbles, y=Points3, size=Points), alpha=.5)+
  geom_jitter(data=Example.Data,aes(x=Bubbles, y=Points4, size=Points), alpha=.5)+
  geom_jitter(data=Example.Data,aes(x=Bubbles, y=Points, size=Points), alpha=.5)+
  geom_jitter(data=Example.Data,aes(x=Bubbles, y=Points2, size=Points), alpha=.5)+
  geom_jitter(data=Example.Data,aes(x=Bubbles, y=Points, size=Points), alpha=.5)+
  geom_jitter(data=Example.Data,aes(x=Bubbles, y=Points2, size=Points), alpha=.5)+
  geom_jitter(data=Example.Data,aes(x=Bubbles, y=Points3, size=Points), alpha=.5)+
  geom_jitter(data=Example.Data,aes(x=Bubbles, y=Points4, size=Points), alpha=.5)+
  geom_jitter(data=Example.Data,aes(x=Bubbles, y=Points2, size=Points), alpha=.5)+
  geom_jitter(data=Example.Data,aes(x=Bubbles, y=Points5, size=Points), alpha=.5)+
  geom_jitter(data=Example.Data,aes(x=Bubbles, y=Points5, size=Points), alpha=.5)+
  geom_jitter(data=Example.Data,aes(x=Bubbles, y=Points6, size=Points), alpha=.5)+
  geom_jitter(data=Example.Data,aes(x=Bubbles, y=Points6, size=Points), alpha=.5)+
  geom_jitter(data=Example.Data,aes(x=Bubbles, y=Points7, size=Points), alpha=.5)+
  geom_jitter(data=Example.Data,aes(x=Bubbles, y=Points7, size=Points), alpha=.5)

Za każdym razem, gdy wykres jest uruchamiany, jitter ustawia `` bąbelki '' w inny sposób, ale oto jedno z ładniejszych wyników, jakie miałem:

wprowadź opis obrazu tutaj

Czasami „bąbelki” będą drgać poza granicami. Jeśli tak się stanie, uruchom ponownie lub po prostu wyeksportuj w większych wymiarach. Więcej bąbelków można nanieść na każdy przyrost na osi y, co wypełni więcej pustej przestrzeni, jeśli sobie tego życzysz.

To daje do 7 wzorów (jeśli uwzględnisz przeciwległe pochylone ukośne linie i ukośną siatkę obu), które można zhakować w ggplot.

Jeśli ktoś może coś przemyśleć, możesz zasugerować więcej.

EDYCJA 4: Pracowałem nad funkcją opakowującą, aby zautomatyzować kreskowanie / wzorce w ggplot2. Po rozszerzeniu funkcji opublikuję link, aby umożliwić stosowanie wzorców na wykresach facet_grid itp. Oto wyjście z danymi wejściowymi funkcji dla prostego wykresu słupków jako przykład:

wprowadź opis obrazu tutaj

Dodam ostatnią edycję, gdy będę mieć funkcję gotową do udostępnienia.

EDYCJA 5: Oto link do funkcji EggHatch, którą napisałem, aby trochę ułatwić proces dodawania wzorców do wykresów geom_bar.

Docconcoct
źródło
Dobra robota! Wydaje się jednak, że to rozwiązanie działa tylko w przypadku wykresów słupkowych lub?
SkyWalker
@Giovanni Azua Próbowałem tego tylko dla działek barowych, tak. Kiedy znajdę czas, spróbuję dostosować połączoną funkcję do wykresów piętrowych itp.
Docconcoct
71

Obecnie nie jest to możliwe, ponieważ grid (system graficzny używany przez ggplot2 do rysowania) nie obsługuje tekstur. Przepraszam!

hadley
źródło
70
Czy planujesz dodać gridextra jako zależność w celu uzyskania tej funkcjonalności?
russellpierce
Jakieś wieści na ten temat?
Hrant
To może się zmienić w niedalekiej przyszłości. Zobacz tę dyskusję , opierając się na nadchodzące zmiany pakietu R w sieci .
stragu
22

Możesz użyć pakietu ggtextures autorstwa @claus wilke do rysowania prostokątów i słupków z teksturą za pomocą ggplot2.

# Image/pattern randomly selected from README
path_image <- "http://www.hypergridbusiness.com/wp-content/uploads/2012/12/rocks2-256.jpg"

library(ggplot2)
# devtools::install_github("clauswilke/ggtextures")
ggplot(mtcars, aes(cyl, mpg)) + 
  ggtextures::geom_textured_bar(stat = "identity", image = path_image)

wprowadź opis obrazu tutaj

Możesz również połączyć to z innymi geomami:

data_raw <- data.frame(x = round(rbinom(1000, 50, 0.1)))
ggplot(data_raw, aes(x)) +
  geom_textured_bar(
    aes(y = ..prop..), image = path_image
  ) +
  geom_density()

wprowadź opis obrazu tutaj

PoGibas
źródło
2
Dziękujemy za przeniesienie odpowiedzi na @PoGibas. Założę się, że w tym przypadku będzie to o wiele bardziej (zasłużona) uwaga! Pozdrawiam
Henrik
Bardzo fajne rozwiązanie.
Docconcoct,
4
Sprawdź wzory do pobrania tutaj: heropatterns.com
Nova
Teraz muszę się tylko dowiedzieć, jak zmienić ich przezroczystość w R .. haha
Nova
3

Właśnie odkryłem pakiet o nazwie ggpattern( https://github.com/coolbutuseless/ggpattern ), który wydaje się być dobrym rozwiązaniem tego problemu i dobrze integruje się z przepływem pracy ggplot2. Chociaż rozwiązania wykorzystujące tekstury mogą działać dobrze w przypadku prętów ukośnych, nie generują grafiki wektorowej i dlatego nie są optymalne.

Oto przykład wzięty prosto z repozytorium github ggpattern:

install.packages("remotes")
remotes::install_github("coolbutuseless/ggpattern")

library(ggplot2)
library(ggpattern)

df <- data.frame(level = c("a", "b", "c", 'd'), outcome = c(2.3, 1.9, 3.2, 1))

ggplot(df) +
  geom_col_pattern(
    aes(level, outcome, pattern_fill = level), 
    pattern = 'stripe',
    fill    = 'white',
    colour  = 'black'
  ) +
  theme_bw(18) +
  theme(legend.position = 'none') + 
  labs(
    title    = "ggpattern::geom_pattern_col()",
    subtitle = "pattern = 'stripe'"
  ) +
  coord_fixed(ratio = 1/2)

co prowadzi do tego wykresu:

przykładowy wykres ggpattern

Jeśli tylko niektóre paski powinny być w paski, geom_col_pattern()ma pattern_alphaargument, który może być użyty do całkowitego przezroczystości niektórych niechcianych pasków.

fujiu
źródło
2

Myślę, że praca Docconcoct jest świetna, ale teraz nagle wygooglowałem specjalny pakiet --- Patternplot . Nie widziałem kodu wewnętrznego, ale winieta wydaje się przydatna.

UlvHare
źródło
1

Przydatne może być utworzenie fikcyjnej ramki danych, której kontury odpowiadają „teksturom”, a następnie użycie geom_contour. Oto mój przykład:

library(ggplot2)

eg = expand.grid(R1 = seq(0,1,by=0.01), R2 = seq(0,1,by=0.01))
     eg$importance = (eg$R1+eg$R2)/2

  ggplot(eg , aes(x = R1, y = R2)) +
  geom_raster(aes(fill = importance), interpolate=TRUE) +
  scale_fill_gradient2(low="white", high="gray20", limits=c(0,1)) +
  theme_classic()+
  geom_contour(bins=5,aes(z=importance), color="black", size=0.6)+
  coord_fixed(ratio = 1, xlim=c(0,1),ylim=c(0,1))

A oto wynik: cieniowana działka z liniami

(linie powinny być wygładzone)

Ondrej Vencalek
źródło