मैं, इस सवाल का जवाब ऊपर लिख रहा हूँ आंशिक रूप से भावी पीढ़ी के लिए, और आंशिक रूप क्योंकि मैं कुछ अन्य लोगों के लिए इस तरह की कुछ कार्यों को लिखने के लिए अर्थ किया गया है जो आर में कस्टम दृश्यावलोकन में प्राप्त करने की कोशिश की है
पृष्ठभूमि
आर में, कई लोग ठीक ही आधार के पीछे कार्यों की साजिश रचने छोड़ने के लिए और अधिक लचीला आवरण संकुल की ओर रुख करने के लिए शुरू, 'जाली' और ' ggplot2 '। ये एक ही साजिश के शीर्ष पर तर्क की परतों को लागू करके अपने डेटा को तेजी से खोजने के लिए शक्तिशाली उपकरण हैं। पैकेज तब सभी परतों को संसाधित करते हैं और भूखंडों की एक खिड़की का उत्पादन करते हैं, उचित तरीके से व्यवस्थित होते हैं। ये पैकेज अद्भुत हैं, और मैं सलाह देता हूं कि प्रत्येक आर उपयोगकर्ता उनमें से कम से कम एक सीखें।
हालांकि, एक चेतावनी यह है कि 'जाली' और 'ggplot2' पैकेज बुद्धिमान डेटा विज़ुअलाइज़ेशन की तुलना में डेटा अन्वेषण के लिए वास्तव में अधिक हैं। एक कस्टम डेटा विज़ुअलाइजेशन बनाते समय, ये पैकेज आपके लिए बहुत से निर्णय लेते हैं, क्योंकि यह एक रैपर है: अपने हाथों से कुछ निर्णय लेना।
कस्टम विज़ुअलाइजेशन? 'ग्रिड'
आधार 'ग्रिड' पैकेज लचीलापन ड्राइंग में सबसे अच्छा है, आंशिक रूप से क्योंकि यह उन्हें लपेटने के बजाए आधार साजिश कार्यों की कार्यक्षमता को बढ़ाता है। 'ग्रिड' कार्यों के साथ, हम नियुक्ति और आकार के लिए विभिन्न इकाइयों का उपयोग करके दृश्य वस्तुओं को बनाने की क्षमता प्राप्त करते हैं, और (यह वास्तव में महत्वपूर्ण है) हम अपने ऑब्जेक्ट्स एंकरों के लिए औचित्य का उपयोग करने की क्षमता प्राप्त करते हैं। यदि आप सीखना चाहते हैं तो पॉल मुरेल की पुस्तक "आर ग्राफिक्स" एक उत्कृष्ट संसाधन है। इसकी एक प्रति मेरी मेज पर बैठती है।
यदि आपने कभी भी वेक्टर ग्राफिक्स ड्राइंग प्रोग्राम (जैसे इलस्ट्रेटर या इंकस्केप) का उपयोग किया है, तो शायद आप पहले ही जानते हैं कि जब मैं औचित्य का उल्लेख करता हूं तो मैं किस बारे में बात कर रहा हूं। यह अन्य वस्तुओं के स्थानों का संदर्भ देकर वस्तुओं को लाइन करने की क्षमता है। मैं इसके बारे में और बात करूंगा, लेकिन मैं पूरे दिन इसके बारे में बात कर सकता था। आइए प्रक्रिया पर आगे बढ़ें।
प्रक्रिया
अब, मैं यह कह कर इस प्रस्तावना चाहिए मेरे बारे में दो घंटे के समारोह पुस्तकालय लिखने के बारे में 5 मिनट लग गए, और डेमो कोड लिखने के लिए। मैं एक प्रशिक्षण उपकरण के रूप में भविष्य में फ़ंक्शन लाइब्रेरी का उपयोग करूँगा, और कोई भी इसे उपयोग/संशोधित करने के लिए स्वतंत्र महसूस कर सकता है।
The 'ग्रिड' प्रक्रिया तीन बुनियादी चरणों में काम करता है:
- एक व्यूपोर्ट
- बनाओ कुछ वस्तुओं
- आपका व्यूपोर्ट
पॉप करने वाला व्यूपोर्ट बनाने में ड्रा, हम का उपयोग करें ' 'व्यूपोर्ट' ऑब्जेक्ट को धक्का देने के लिए पुशव्यूपोर्ट ', कुछ ऐसा:
pushViewport(viewport(x=0, y=1, xscale=c(1, 10), yscale=c(0, 100), width=0.25, height=0.25, default.units="npc", just=c("left","bottom"), clip="off"))
मूल व्यूपोर्ट में इकाइयों का एक "एनपीसी" सेट होता है जहां एक्स 0 से 1 तक जाता है, बाएं से दाएं, और y 0 से 1 तक नीचे जाता है, नीचे से ऊपर। इसका मतलब है कि मूल निचले बाएं कोने में है। उपरोक्त व्यूपोर्ट को निचले बाएं कोने में साजिश का एक चौथाई भाग के रूप में बनाया गया है। जब हम एक "xscale" और "yscale" निर्दिष्ट करते हैं, हालांकि, हम वस्तुओं को चित्रित करते समय इकाइयों को "मूल" संदर्भित करने की क्षमता प्राप्त करते हैं। इसका मतलब है कि हम डेटा खींचने के लिए "मूल" इकाइयों का उपयोग कर सकते हैं और अक्ष और लेबल जैसी चीजें खींचते समय "एनपीसी" इकाइयों का उपयोग कर सकते हैं।
वस्तुओं को चित्रित करते समय, हम 'grid.lines', 'grid.polygon', 'grid.points', 'grid.circle' जैसे कार्यों का उपयोग करते हैं, और इसी तरह। मैंने जो भी विज़ुअलाइज़ेशन किया है, वह इन वस्तुओं का उपयोग करता है। जब आप इन ऑब्जेक्ट्स को हाथ से निर्दिष्ट करके डेटा खींचते हैं, तो आपको बहुत अधिक नियंत्रण प्राप्त होता है। एक लाइन चार्ट भरना अतिरिक्त क्षमता के सबसे स्पष्ट उदाहरणों में से एक है। एक भरा क्षेत्र केवल डेटा द्वारा निर्दिष्ट बहुभुज के बिंदुओं के साथ एक बहुभुज है और दो एंकर पॉइंट जोड़े गए हैं। मैं लाइन चार्ट के क्षेत्रों को हाइलाइट करने के लिए या उसी चार्ट पर एकाधिक लाइनों को पढ़ने में आसान बनाने के लिए इसका उपयोग करता हूं।
आप क्रिएटिव भी प्राप्त कर सकते हैं, उदाहरण के लिए, आयताकार नहीं हैं, या एक अधिक परिष्कृत तरीके से कई भूखंडों को जोड़ते हैं। मैं और कुछ अन्य ने हाल ही में एक विज्ञान-फाई थीमाधारित चलने वाला गेम चलाया, और हमने अपने अंतिम प्रदर्शन को प्रदर्शित करने के लिए एक कस्टम चार्ट ('ग्रिड' के साथ बनाया) का उपयोग किया।चार्ट "उत्तरजीवी" टीम पर समय अक्ष के रूप में दिनों की संख्या को जोड़ता है, बार चार्ट के रूप में प्रति दिन खिलाड़ी बनाम दुश्मन कदम प्रदर्शित करता है, और एक भरे हुए लाइन चार्ट के रूप में प्रति दिन संचयी खिलाड़ी और दुश्मन कदम प्रदर्शित करता है। मुझे 'जाली' या 'ggplot2' पैकेज का उपयोग करके तुलनीय दृश्य बनाने के लिए कठोर दबाव डालना होता।
सबूत:
यहाँ चार्ट में से एक (बिना वास्तविक जीवन खिलाड़ी नाम) का एक नमूना है, बस कैसे लचीला 'ग्रिड' दृश्यों हो सकता है की एक विचार दे रहा है प्रश्न
अब ओपी द्वारा उत्पन्न प्रश्न को संबोधित करने के लिए अवधारणा के लिए। प्रश्न में, ओपी का तात्पर्य है कि वह प्रत्येक क्षेत्र के भीतर चार्ट प्लॉट करेगा। प्री-बिल्ट प्लॉटिंग पैकेज का उपयोग करते समय यह मुश्किल हो सकता है, क्योंकि अधिकांश प्लॉटिंग फ़ंक्शंस आपके द्वारा पहले से सेट किए गए किसी भी प्लॉट विनिर्देशों को ओवरराइट कर देंगे। इसके बजाए, प्लॉटिंग क्षेत्रों को निर्दिष्ट करने के लिए बेस 'ग्रिड' फ़ंक्शंस जैसे कुछ का उपयोग करना और फिर व्यूपोर्ट्स के भीतर आवश्यक डेटा ऑब्जेक्ट्स को आकर्षित करना अधिक विश्वसनीय है।
बहुत मेहनत से काम करने के लिए, मैंने पहले एक कस्टम फ़ंक्शन लाइब्रेरी लिखी जो मेरे विभिन्न चार्ट पैरामीटर सेट करता है और मेरे लिए प्रत्येक प्रकार का चार्ट खींचता है। मुझे डिबगिंग कोड पसंद नहीं है, इसलिए काम मैं चीजों के माध्यम से काम करता हूं। प्रत्येक बार जब मुझे सही कोड का टुकड़ा मिलता है, तो मैं इसे बाद में उपयोग के लिए एक फ़ंक्शन में फेंक देता हूं।
कोड थोड़ा जटिल लग सकता है, लेकिन तीन 'ग्रिड' चरणों को याद रखें: पुश व्यूपोर्ट, ड्रा, पॉप व्यूपोर्ट। यह वही है जो प्रत्येक कार्य कर रहा है। काम को डेमो करने के लिए, मैंने चार अलग-अलग ड्राइंग फ़ंक्शन किए: ओपी द्वारा सुझाए गए अनुसार लाइन लाइन चार्ट, स्कैटर प्लॉट, हिस्टोग्राम और एक बॉक्स ड्राइंग। प्रत्येक फ़ंक्शन प्रत्येक चार्ट में डेटा मानों के एकाधिक सेट को समायोजित करने के लिए पर्याप्त लचीला है, अल्फा मानों को सेट करने और हमें एक-दूसरे के ऊपर प्लॉट किए गए मान देखने की इजाजत देता है।
इस तरह के मामले में, आप केवल अपने कार्यों को उतना ही लचीला बनाते हैं जितना आपको चाहिए, इसलिए मैंने लाइनों पर एक शॉर्टकट लिया और उन्हें डेमो में थोड़ा सा कोड खींचा जिसने बहुत सी धारणाएं कीं। मैंने अभी भी लॉजिक-संचालित कोड के साथ इसे आकर्षित किया है, हालांकि, सरल तर्क के साथ अधिक जटिल वस्तुओं को आकर्षित करने के तरीके को प्रदर्शित करने के लिए।
यहाँ, डेमो कोड का परिणाम है आसान डेटा (EuStockMarkets, nottem, sunspots.month) के लिए कुछ में निर्मित आर डेटासेट का उपयोग कर:
कस्टम समारोह पुस्तकालय :
library(grid)
# Specify general chart options.
chart_Fill = "lemonchiffon"
chart_Col = "snow3"
space_Background = "white"
title_CEX = 0.8
axis_CEX = 0.6
chart_Width <- 3/3
chart_Height <- 2/5
# Function to initialize a plotting area.
init_Plot <- function(
.df,
.x_Loc,
.y_Loc,
.justify,
.width,
.height
){
# Initialize plotting area to fit data.
# We have to turn off clipping to make it
# easy to plot the labels around the plot.
pushViewport(viewport(xscale=c(min(.df[,1]), max(.df[,1])), yscale=c(min(0,min(.df[,-1])), max(.df[,-1])), x=.x_Loc, y=.y_Loc, width=.width, height=.height, just=.justify, clip="off", default.units="native"))
# Color behind text.
grid.rect(x=0, y=0, width=unit(axis_CEX, "lines"), height=1, default.units="npc", just=c("right", "bottom"), gp=gpar(fill=space_Background, col=space_Background))
grid.rect(x=0, y=1, width=1, height=unit(title_CEX, "lines"), default.units="npc", just=c("left", "bottom"), gp=gpar(fill=space_Background, col=space_Background))
# Color in the space.
grid.rect(gp=gpar(fill=chart_Fill, col=chart_Col))
}
# Function to finalize and label a plotting area.
finalize_Plot <- function(
.df,
.plot_Title
){
# Label plot using the internal reference
# system, instead of the parent window, so
# we always have perfect placement.
grid.text(.plot_Title, x=0.5, y=1.05, just=c("center","bottom"), rot=0, default.units="npc", gp=gpar(cex=title_CEX))
grid.text(paste(names(.df)[-1], collapse=" & "), x=-0.05, y=0.5, just=c("center","bottom"), rot=90, default.units="npc", gp=gpar(cex=axis_CEX))
grid.text(names(.df)[1], x=0.5, y=-0.05, just=c("center","top"), rot=0, default.units="npc", gp=gpar(cex=axis_CEX))
# Finalize plotting area.
popViewport()
}
# Function to plot a filled line chart of
# the data in a data frame. The first column
# of the data frame is assumed to be the
# plotting index, with each column being a
# set of y-data to plot. All data is assumed
# to be numeric.
plot_Line_Chart <- function(
.df,
.x_Loc,
.y_Loc,
.justify,
.width,
.height,
.colors,
.plot_Title
){
# Initialize plot.
init_Plot(.df, .x_Loc, .y_Loc, .justify, .width, .height)
# Calculate what value to use as the
# return for the polygons.
y_Axis_Min <- min(0, min(.df[,-1]))
# Plot each set of data as a polygon,
# so we can fill it in with color to
# make it easier to read.
for (i in 2:ncol(.df)){
grid.polygon(x=c(min(.df[,1]),.df[,1], max(.df[,1])), y=c(y_Axis_Min,.df[,i], y_Axis_Min), default.units="native", gp=gpar(fill=.colors[i-1], col=.colors[i-1], alpha=1/ncol(.df)))
}
# Draw plot axes.
grid.lines(x=0, y=c(0,1), default.units="npc")
grid.lines(x=c(0,1), y=0, default.units="npc")
# Finalize plot.
finalize_Plot(.df, .plot_Title)
}
# Function to plot a scatterplot of
# the data in a data frame. The
# assumptions are the same as 'plot_Line_Chart'.
plot_Scatterplot <- function(
.df,
.x_Loc,
.y_Loc,
.justify,
.width,
.height,
.colors,
.plot_Title
){
# Initialize plot.
init_Plot(.df, .x_Loc, .y_Loc, .justify, .width, .height)
# Plot each set of data as colored points.
for (i in 2:ncol(.df)){
grid.points(x=.df[,1], y=.df[,i], pch=19, size=unit(1, "native"), default.units="native", gp=gpar(col=.colors[i-1], alpha=1/ncol(.df)))
}
# Draw plot axes.
grid.lines(x=0, y=c(0,1), default.units="npc")
grid.lines(x=c(0,1), y=0, default.units="npc")
# Finalize plot.
finalize_Plot(.df, .plot_Title)
}
# Function to plot a histogram of
# all the columns in a data frame,
# except the first, which is assumed to
# be an index.
plot_Histogram <- function(
.df,
.x_Loc,
.y_Loc,
.justify,
.width,
.height,
.colors,
.plot_Title,
...
){
# Create a list containing the histogram
# data for each data column and calculate
# data ranges. Any extra parameters
# specified will pass to the 'hist' function.
hist_Data <- list()
hist_Count_Range <- c(0,NA)
hist_Breaks_Range <- c(NA,NA)
for (i in 2:ncol(.df)){
hist_Data[[i]] <- hist(.df[,i], plot=FALSE, ...)
hist_Count_Range[2] <- max(max(hist_Data[[i]]$counts), hist_Count_Range[2], na.rm=TRUE)
hist_Breaks_Range <- c(min(min(hist_Data[[i]]$breaks), hist_Breaks_Range[1], na.rm=TRUE), max(max(hist_Data[[i]]$breaks), hist_Breaks_Range[2], na.rm=TRUE))
}
# Initialize plotting area to fit data.
# We are doing this in a custom way to
# allow more flexibility than built into
# the 'init_Plot' function.
# We have to turn off clipping to make it
# easy to plot the labels around the plot.
pushViewport(viewport(xscale=hist_Breaks_Range, yscale=hist_Count_Range, x=.x_Loc, y=.y_Loc, width=.width, height=.height, just=.justify, clip="off", default.units="native"))
# Color behind text.
grid.rect(x=0, y=0, width=unit(axis_CEX, "lines"), height=1, default.units="npc", just=c("right", "bottom"), gp=gpar(fill=space_Background, col=space_Background))
grid.rect(x=0, y=1, width=1, height=unit(title_CEX, "lines"), default.units="npc", just=c("left", "bottom"), gp=gpar(fill=space_Background, col=space_Background))
# Color in the space.
grid.rect(gp=gpar(fill=chart_Fill, col=chart_Col))
# Draw x axis.
grid.lines(x=c(0,1), y=0, default.units="npc")
# Plot each set of data as a histogram.
for (i in 2:ncol(.df)){
grid.rect(x=hist_Data[[i]]$mids, y=0, width=diff(hist_Data[[i]]$mids[1:2]), height=hist_Data[[i]]$counts, default.units="native", just=c("center","bottom"), gp=gpar(fill=.colors[i-1], col=.colors[i-1], alpha=1/ncol(.df)))
}
# Label plot using the internal reference
# system, instead of the parent window, so
# we always have perfect placement.
grid.text(.plot_Title, x=0.5, y=1.05, just=c("center","bottom"), rot=0, default.units="npc", gp=gpar(cex=title_CEX))
grid.text(paste(names(.df)[-1], collapse=" & "), x=-0.05, y=0.5, just=c("center","bottom"), rot=90, default.units="npc", gp=gpar(cex=axis_CEX))
# Finalize plotting area.
popViewport()
}
draw_Sample_Box <- function(
.x_Loc,
.y_Loc,
.x_Scale,
.y_Scale,
.justify,
.width,
.height,
.colors,
.box_X,
.box_Y,
.plot_Title
){
pushViewport(viewport(xscale=.x_Scale, yscale=.y_Scale, x=.x_Loc, y=.y_Loc, width=chart_Width, height=chart_Height, just=.justify, clip="off", default.units="native"))
# Color behind text.
grid.rect(x=0, y=1, width=1, height=unit(title_CEX, "lines"), default.units="npc", just=c("left", "bottom"), gp=gpar(fill=space_Background, col=space_Background))
# Color in the space.
grid.rect(gp=gpar(fill=chart_Fill, col=chart_Col))
# Label plot.
grid.text(.plot_Title, x=0.5, y=1.05, just=c("center","bottom"), rot=0, default.units="npc", gp=gpar(cex=title_CEX))
# Draw box and label points.
grid.polygon(x=.box_X, y=.box_Y, default.units="native", gp=gpar(fill=.colors[1], col=.colors[2]))
grid.text(paste(.plot_Title, 1, sep=""), x=min(.box_X), y=min(.box_Y), default.units="native", just=c("right","top"), gp=gpar(cex=0.5))
grid.text(paste(.plot_Title, 2, sep=""), x=max(.box_X), y=min(.box_Y), default.units="native", just=c("left","top"), gp=gpar(cex=0.5))
# Finalize plot.
popViewport()
}
डेमो कोड:
# Draw twelve independent charts as
# a demo and connect with lines similar
# to a heiritage chart.
grid.newpage()
# Initialize a viewport to make our locations
# easier to map.
pushViewport(viewport(x=0, y=0, width=1, height=1, just=c("left","bottom"), xscale=c(0,10), yscale=c(0,4)))
# Color background of overall plot.
grid.rect(gp=gpar(fill=space_Background, col=space_Background))
# Store plot locations for convenience.
plot_Loc <- data.frame(x=c(2,4,6,8,1,3,7,9,2,4,6,8), y=c(3,3,3,3,2,2,2,2,1,1,1,1))
# Draw connecting lines.
connections <- data.frame(a=c(1, 3, 5, 6, 7, 1, 3, 5, 7, 6), b=c(2, 4, 6, 7, 8, 2, 4, 6, 8, 7), c=c(NA, NA, NA, NA, NA, 6, 7, 9, 12, 10), d=c(NA, NA, NA, NA, NA, NA, NA, NA, NA, 11))
for (i in 1:nrow(connections)){
if (is.na(connections$c[i])){
grid.lines(x=plot_Loc$x[unlist(connections[i,1:2])], y=plot_Loc$y[unlist(connections[i,1:2])], default.units="native")
} else if (is.na(connections$d[i])) {
grid.lines(x=median(plot_Loc$x[unlist(connections[i,1:2])]), y=plot_Loc$y[unlist(connections[i,2:3])], default.units="native")
} else {
grid.lines(x=median(plot_Loc$x[unlist(connections[i,1:2])]), y=c(plot_Loc$y[connections[i,2]], median(plot_Loc$y[unlist(connections[i,2:3])])), default.units="native")
grid.lines(x=plot_Loc$x[unlist(connections[i,3:4])], y=median(plot_Loc$y[unlist(connections[i,2:3])]), default.units="native")
grid.lines(x=plot_Loc$x[connections[i,3]], y=c(median(plot_Loc$y[unlist(connections[i,2:3])]), plot_Loc$y[connections[i,3]]), default.units="native")
grid.lines(x=plot_Loc$x[connections[i,4]], y=c(median(plot_Loc$y[unlist(connections[i,2:3])]), plot_Loc$y[connections[i,4]]), default.units="native")
}
}
# Draw four independent line charts.
p <- 1
plot_Line_Chart(data.frame(time=1:1860, EuStockMarkets)[1:3], .x_Loc=plot_Loc$x[p], .y_Loc=plot_Loc$y[p], .just=c("center","center"), .width=chart_Width, .height=chart_Height, c("dodgerblue", "deeppink"), "EU Stocks")
p <- 2
plot_Line_Chart(data.frame(time=1:1860, EuStockMarkets)[c(1,4,5)], .x_Loc=plot_Loc$x[p], .y_Loc=plot_Loc$y[p], .just=c("center","center"), .width=chart_Width, .height=chart_Height, c("green", "purple"), "EU Stocks")
p <- 3
plot_Line_Chart(data.frame(time=1:(12*20), sunspots=sunspot.month[(171*12+1):(171*12+12*20)]), .x_Loc=plot_Loc$x[p], .y_Loc=plot_Loc$y[p], .just=c("center","center"), .width=chart_Width, .height=chart_Height, c("darkgoldenrod"), "Sunspots")
p <- 4
plot_Line_Chart(data.frame(time=1:(12*20), temp=nottem), .x_Loc=plot_Loc$x[p], .y_Loc=plot_Loc$y[p], .just=c("center","center"), .width=chart_Width, .height=chart_Height, c("red"), "Nottem")
# Draw four independent scatterplots.
p <- 5
plot_Scatterplot(data.frame(time=1:(1860 + 1 - 1000), DAX=rowMeans(embed(EuStockMarkets[,1], 1000)), FTSE=rowMeans(embed(EuStockMarkets[,4], 1000))), .x_Loc=plot_Loc$x[p], .y_Loc=plot_Loc$y[p], .just=c("center","center"), .width=chart_Width, .height=chart_Height, c("deeppink", "purple"), "Smooth")
p <- 6
plot_Scatterplot(data.frame(time=1:1860, EuStockMarkets)[c(1,2,5)], .x_Loc=plot_Loc$x[p], .y_Loc=plot_Loc$y[p], .just=c("center","center"), .width=chart_Width, .height=chart_Height, c("deeppink", "purple"), "EU Stocks")
p <- 9
plot_Scatterplot(data.frame(time=1:(1860 + 1 - 20), DAX=rowMeans(embed(EuStockMarkets[,1], 20)), FTSE=rowMeans(embed(EuStockMarkets[,4], 20))), .x_Loc=plot_Loc$x[p], .y_Loc=plot_Loc$y[p], .just=c("center","center"), .width=chart_Width, .height=chart_Height, c("deeppink", "purple"), "Smooth*20")
p <- 10
plot_Scatterplot(data.frame(time=1:(1860 + 1 - 100), DAX=rowMeans(embed(EuStockMarkets[,1], 100)), FTSE=rowMeans(embed(EuStockMarkets[,4], 100))), .x_Loc=plot_Loc$x[p], .y_Loc=plot_Loc$y[p], .just=c("center","center"), .width=chart_Width, .height=chart_Height, c("deeppink", "purple"), "Smooth*100")
# Draw two independent histograms.
p <- 7
plot_Histogram(data.frame(time=1:(12*20), sunspots=sunspot.month[(171*12+1):(171*12+12*20)]), .x_Loc=plot_Loc$x[p], .y_Loc=plot_Loc$y[p], .just=c("center","center"), .width=chart_Width, .height=chart_Height, c("darkgoldenrod"), "Sunspots", breaks=6)
p <- 8
plot_Histogram(data.frame(time=1:(12*20), temp=nottem), .x_Loc=plot_Loc$x[p], .y_Loc=plot_Loc$y[p], .just=c("center","center"), .width=chart_Width, .height=chart_Height, c("red"), "Nottem", breaks=6)
# Draw sample objects in two charts spaces.
p <- 11
draw_Sample_Box(.x_Loc=plot_Loc$x[p], .y_Loc=plot_Loc$y[p], .x_Scale=c(0,10), .y_Scale=c(-10,0), .justify=c("center","center"), .width=chart_Width, .height=chart_Height, .colors=c("dodgerblue","blue"), .box_X=c(4,6,6,4), .box_Y=c(-4,-4,-5,-5), .plot_Title="K")
p <- 12
draw_Sample_Box(.x_Loc=plot_Loc$x[p], .y_Loc=plot_Loc$y[p], .x_Scale=c(-1,1), .y_Scale=c(0,1), .justify=c("center","center"), .width=chart_Width, .height=chart_Height, .colors=c("dodgerblue","blue"), .box_X=c(-0.5,0,0,-0.5), .box_Y=c(0.8,0.8,0.7,0.7), .plot_Title="L")
यह निश्चित रूप से एक वंशावली तरह दिखता है। क्या आपने kinship2 पैकेज देखा है? –
आप ggplot2 के साथ लाइनें खींच सकते हैं, और छोटे प्लॉट को 'annotate_custom' के साथ रख सकते हैं। – baptiste
@DWin निश्चित रूप से वंशावली के रूप में व्यवस्थित है लेकिन आयताकार प्रत्येक एक साजिश है, जो किसी भी वंशावली ड्राइंग पैकेज जैसे कि kinship2 – jon