दिलचस्प पोस्ट
पेजिंग को लागू करने के लिए प्रभावी तरीका घातक त्रुटि एलएनके 1112: मॉड्यूल मशीन प्रकार 'x64' लक्ष्य मशीन प्रकार 'एक्स 86' के साथ संघर्ष आप सी में एक फ़ाइल के आकार का निर्धारण कैसे करते हैं? ग्रिड लेआउट और पंक्ति / कॉलम स्पैन दुःस्वप्न एचटीएमएल के चयन पर मापदंडों को कैसे पारित करें क्या मैं चयनकर्ताओं के लिए चर का उपयोग कर सकता हूं? मैं ओएस और ब्राउज़र जैसे क्लाइंट इन्फॉर्मेशन कैसे प्राप्त कर सकता हूं एक स्कैपी स्पार्सी मैट्रिक्स से पांडस स्पर्सडेटाफ्रेम को पॉप्युलेट करें मैं अलग सी। सी फाइलों के बीच चर कैसे साझा करूं? कमांड लाइन उपकरण काम नहीं कर रहे हैं – ओएस एक्स एल कैपिटन / मैकोज सिएरा / मैकोज़ हाई सिएरा एसक्यूएल जोन: उपयोग, या उसमें क्या अंतर है? com.mysql.jdbc.exceptions.jdbc4.CommunicationsException: संचार लिंक विफलता कनेक्शन का कारण समाप्त हुआ: recv विफल आप टेक्स्टरिए में कर्सर की स्थिति कैसे प्राप्त करते हैं? कमांड प्रॉम्प्ट में जार फ़ाइल चलाएं Gmail में .NET के माध्यम से ईमेल भेजा जा रहा है

R: एक्स, वाई, जेड से एक 3 डी की सतह का प्लॉटिंग

कल्पना करो मेरे पास एक 3 कॉलम मैट्रिक्स है
x, y, z जहां z एक फ़ंक्शन है x और y

मुझे पता है कि प्लॉट 3 plot3d(x,y,z) साथ इन बिंदुओं के "स्कैटर प्लॉट" को कैसे साजिश करना है

लेकिन अगर मुझे एक सतह चाहिए, तो मुझे अन्य आज्ञाओं जैसे सतह 3 डी का उपयोग करना चाहिए, समस्या यह है कि यह एक ही इनपुट को प्लॉट 3 डी के रूप में स्वीकार नहीं करता है, इसके साथ मैट्रिक्स की आवश्यकता होती है

 (nº elements of z) = (n of elements of x) * (n of elements of x) 

मैं इस मैट्रिक्स को कैसे प्राप्त करूं? मैंने कमांड इंटरप के साथ कोशिश की, जैसा कि मैंने किया है जब मुझे समोच्च भूखंडों का उपयोग करना पड़ता है

मैं इस मैट्रिक्स की गणना किए बिना एक्स, वाई, जेड से सीधे सतह को कैसे साजिश कर सकता हूं? अगर मुझे बहुत अधिक अंक मिलते हैं तो मैट्रिक्स बहुत बड़ा होगा।

चियर्स

वेब के समाधान से एकत्रित समाधान "R: एक्स, वाई, जेड से एक 3 डी की सतह का प्लॉटिंग"

यदि आपके एक्स और वाई कॉर्ड एक ग्रिड पर नहीं हैं तो आपको अपने एक्स, वाई, जेड सतह को एक पर घुसना होगा। आप ऐसा कर सकते हैं कि किसी भी भू-ऑप्टिस्टिक पैकेज (geoR, gstat, अन्य) या साधारण तकनीक जैसे व्युत्क्रम दूरी भार

मैं अनुमान लगा रहा हूं कि 'इंटरप' फ़ंक्शन जिसका आप उल्लेख करते हैं, अकीमा पैकेज से है। ध्यान दें कि आउटपुट मैट्रिक्स आपके इनपुट पॉइंट के आकार से स्वतंत्र है। अगर आप चाहें तो 10×10 ग्रिड पर आपके इनपुट में 10000 अंक हो सकते हैं और उस पर दोहरा सकते हैं डिफ़ॉल्ट रूप से akima :: interp यह 40×40 ग्रिड पर करता है:

 > require(akima) ; require(rgl) > x=runif(1000) > y=runif(1000) > z=rnorm(1000) > s=interp(x,y,z) > dim(s$z) [1] 40 40 > surface3d(s$x,s$y,s$z) 

वह नुकीला और बकवास दिखेंगे क्योंकि इसकी यादृच्छिक डेटा उम्मीद है कि आपका डेटा नहीं है!

आप जाली का उपयोग कर देख सकते हैं इस उदाहरण में मैंने एक ग्रिड परिभाषित किया है जिस पर मैं z ~ x, y प्लॉट करना चाहता हूं। ऐसा कुछ दिखता है ध्यान दें कि अधिकांश कोड सिर्फ 3 डी आकृति का निर्माण कर रहा है जो कि मैं वायरफ्रेम फ़ंक्शन का उपयोग करके प्लॉट करता हूं।

चर "बी" और "एस" x या y हो सकते हैं

 require(lattice) # begin generating my 3D shape b <- seq(from=0, to=20,by=0.5) s <- seq(from=0, to=20,by=0.5) payoff <- expand.grid(b=b,s=s) payoff$payoff <- payoff$b - payoff$s payoff$payoff[payoff$payoff < -1] <- -1 # end generating my 3D shape wireframe(payoff ~ s * b, payoff, shade = TRUE, aspect = c(1, 1), light.source = c(10,10,10), main = "Study 1", scales = list(z.ticks=5,arrows=FALSE, col="black", font=10, tck=0.5), screen = list(z = 40, x = -75, y = 0)) 

आप इसे उत्पन्न करने के लिए फ़ंक्शन outer() का उपयोग कर सकते हैं।

फ़ंक्शन के लिए डेमो पर नजर डालें persp() , जो सतहों के लिए परिप्रेक्ष्य भूखंडों को आकर्षित करने के लिए आधार ग्राफिक्स फ़ंक्शन है।

यहां उनका पहला उदाहरण है:

 x <- seq(-10, 10, length.out = 50) y <- x rotsinc <- function(x,y) { sinc <- function(x) { y <- sin(x)/x ; y[is.na(y)] <- 1; y } 10 * sinc( sqrt(x^2+y^2) ) } z <- outer(x, y, rotsinc) persp(x, y, z) 

वही surface3d() पर लागू होता है:

 require(rgl) surface3d(x, y, z) 

rgl महान है, लेकिन अक्षों सही पाने के लिए थोड़ा प्रयोग लेता है।

यदि आपके पास बहुत सारे बिंदु हैं, तो उनमें से एक यादृच्छिक नमूना क्यों न लें, और फिर परिणामस्वरूप सतह का पता लगाएं। आप एक ही डेटा से नमूनों के आधार पर कई सतहों को जोड़ सकते हैं कि यह देखने के लिए कि नमूनाकरण की प्रक्रिया आपके डेटा को बुरी तरह प्रभावित कर रही है या नहीं।

तो, यह एक बहुत ही भयानक समारोह है, लेकिन ऐसा लगता है कि मुझे लगता है कि आप इसे करना चाहते हैं (लेकिन बिना नमूना)। एक मैट्रिक्स को देखते हुए (x, y, z) जहां z ऊंचा है, यह दोनों बिंदुओं और सतह को भी चित्रित करेगा। सीमाएं हैं कि प्रत्येक (एक्स, वाई) जोड़ी के लिए केवल एक z हो सकती है इसलिए वे विमान जो स्वयं पर लूप को वापस लेते हैं, वे समस्याएं पैदा कर सकते हैं।

plot_points = T , उन व्यक्तिगत बिंदुओं को plot_points = T करेगा जिनसे सतह बनायी जाती है – यह जांचना उपयोगी है कि सतह और अंक वास्तव में मिलते हैं। plot_contour = T 3 डी विज़ुअलाइजेशन के नीचे एक 2 डी समोच्च साजिश का प्लॉट करेगा। सुंदर रंग देने के लिए rainbow लिए रंग सेट करें, और कुछ भी इसे ग्रे पर सेट कर देगा, लेकिन फिर आप एक कस्टम पैलेट देने के लिए फ़ंक्शन को बदल सकते हैं। यह वैसे भी मेरे लिए चाल करता है, लेकिन मुझे यकीन है कि इसे ट्रिड किया जा सकता है और अनुकूलित किया जा सकता है verbose = T बहुत सारे आउटपुट को प्रिंट करता है जो मैं फ़ंक्शन को डिबग करने के लिए उपयोग करता हूं और जब यह टूट जाता है।

 plot_rgl_model_a <- function(fdata, plot_contour = T, plot_points = T, verbose = F, colour = "rainbow", smoother = F){ ## takes a model in long form, in the format ## 1st column x ## 2nd is y, ## 3rd is z (height) ## and draws an rgl model ## includes a contour plot below and plots the points in blue ## if these are set to TRUE # note that x has to be ascending, followed by y if (verbose) print(head(fdata)) fdata <- fdata[order(fdata[, 1], fdata[, 2]), ] if (verbose) print(head(fdata)) ## require(reshape2) require(rgl) orig_names <- colnames(fdata) colnames(fdata) <- c("x", "y", "z") fdata <- as.data.frame(fdata) ## work out the min and max of x,y,z xlimits <- c(min(fdata$x, na.rm = T), max(fdata$x, na.rm = T)) ylimits <- c(min(fdata$y, na.rm = T), max(fdata$y, na.rm = T)) zlimits <- c(min(fdata$z, na.rm = T), max(fdata$z, na.rm = T)) l <- list (x = xlimits, y = ylimits, z = zlimits) xyz <- do.call(expand.grid, l) if (verbose) print(xyz) x_boundaries <- xyz$x if (verbose) print(class(xyz$x)) y_boundaries <- xyz$y if (verbose) print(class(xyz$y)) z_boundaries <- xyz$z if (verbose) print(class(xyz$z)) if (verbose) print(paste(x_boundaries, y_boundaries, z_boundaries, sep = ";")) # now turn fdata into a wide format for use with the rgl.surface fdata[, 2] <- as.character(fdata[, 2]) fdata[, 3] <- as.character(fdata[, 3]) #if (verbose) print(class(fdata[, 2])) wide_form <- dcast(fdata, y ~ x, value_var = "z") if (verbose) print(head(wide_form)) wide_form_values <- as.matrix(wide_form[, 2:ncol(wide_form)]) if (verbose) print(wide_form_values) x_values <- as.numeric(colnames(wide_form[2:ncol(wide_form)])) y_values <- as.numeric(wide_form[, 1]) if (verbose) print(x_values) if (verbose) print(y_values) wide_form_values <- wide_form_values[order(y_values), order(x_values)] wide_form_values <- as.numeric(wide_form_values) x_values <- x_values[order(x_values)] y_values <- y_values[order(y_values)] if (verbose) print(x_values) if (verbose) print(y_values) if (verbose) print(dim(wide_form_values)) if (verbose) print(length(x_values)) if (verbose) print(length(y_values)) zlim <- range(wide_form_values) if (verbose) print(zlim) zlen <- zlim[2] - zlim[1] + 1 if (verbose) print(zlen) if (colour == "rainbow"){ colourut <- rainbow(zlen, alpha = 0) if (verbose) print(colourut) col <- colourut[ wide_form_values - zlim[1] + 1] # if (verbose) print(col) } else { col <- "grey" if (verbose) print(table(col2)) } open3d() plot3d(x_boundaries, y_boundaries, z_boundaries, box = T, col = "black", xlab = orig_names[1], ylab = orig_names[2], zlab = orig_names[3]) rgl.surface(z = x_values, ## these are all different because x = y_values, ## of the confusing way that y = wide_form_values, ## rgl.surface works! - y is the height! coords = c(2,3,1), color = col, alpha = 1.0, lit = F, smooth = smoother) if (plot_points){ # plot points in red just to be on the safe side! points3d(fdata, col = "blue") } if (plot_contour){ # plot the plane underneath flat_matrix <- wide_form_values if (verbose) print(flat_matrix) y_intercept <- (zlim[2] - zlim[1]) * (-2/3) # put the flat matrix 1/2 the distance below the lower height flat_matrix[which(flat_matrix != y_intercept)] <- y_intercept if (verbose) print(flat_matrix) rgl.surface(z = x_values, ## these are all different because x = y_values, ## of the confusing way that y = flat_matrix, ## rgl.surface works! - y is the height! coords = c(2,3,1), color = col, alpha = 1.0, smooth = smoother) } } 

add_rgl_model विकल्प के बिना एक ही काम करता है, लेकिन मौजूदा 3dplot पर एक सतह को ओवरले करता है।

 add_rgl_model <- function(fdata){ ## takes a model in long form, in the format ## 1st column x ## 2nd is y, ## 3rd is z (height) ## and draws an rgl model ## # note that x has to be ascending, followed by y print(head(fdata)) fdata <- fdata[order(fdata[, 1], fdata[, 2]), ] print(head(fdata)) ## require(reshape2) require(rgl) orig_names <- colnames(fdata) #print(head(fdata)) colnames(fdata) <- c("x", "y", "z") fdata <- as.data.frame(fdata) ## work out the min and max of x,y,z xlimits <- c(min(fdata$x, na.rm = T), max(fdata$x, na.rm = T)) ylimits <- c(min(fdata$y, na.rm = T), max(fdata$y, na.rm = T)) zlimits <- c(min(fdata$z, na.rm = T), max(fdata$z, na.rm = T)) l <- list (x = xlimits, y = ylimits, z = zlimits) xyz <- do.call(expand.grid, l) #print(xyz) x_boundaries <- xyz$x #print(class(xyz$x)) y_boundaries <- xyz$y #print(class(xyz$y)) z_boundaries <- xyz$z #print(class(xyz$z)) # now turn fdata into a wide format for use with the rgl.surface fdata[, 2] <- as.character(fdata[, 2]) fdata[, 3] <- as.character(fdata[, 3]) #print(class(fdata[, 2])) wide_form <- dcast(fdata, y ~ x, value_var = "z") print(head(wide_form)) wide_form_values <- as.matrix(wide_form[, 2:ncol(wide_form)]) x_values <- as.numeric(colnames(wide_form[2:ncol(wide_form)])) y_values <- as.numeric(wide_form[, 1]) print(x_values) print(y_values) wide_form_values <- wide_form_values[order(y_values), order(x_values)] x_values <- x_values[order(x_values)] y_values <- y_values[order(y_values)] print(x_values) print(y_values) print(dim(wide_form_values)) print(length(x_values)) print(length(y_values)) rgl.surface(z = x_values, ## these are all different because x = y_values, ## of the confusing way that y = wide_form_values, ## rgl.surface works! coords = c(2,3,1), alpha = .8) # plot points in red just to be on the safe side! points3d(fdata, col = "red") } 

तो मेरा दृष्टिकोण होगा, इसे अपने सभी डेटा के साथ करने की कोशिश करें (मैं आसानी से ~ 15 के अंक से उत्पन्न सतहों को साजिश कर सकता हूं)। अगर वह काम नहीं करता है, तो इन छोटे छोटे नमूनों को ले लीजिए और इन सभी कार्यों का उपयोग करके उन्हें एक बार साजिश कर दें।

शायद अब देर हो चुकी है, लेकिन स्पेसैनैन के बाद, क्या आपने डुप्लिकेट = "स्ट्रिप" या किसी अन्य विकल्प की कोशिश की?

 x=runif(1000) y=runif(1000) z=rnorm(1000) s=interp(x,y,z,duplicate="strip") surface3d(s$x,s$y,s$z,color="blue") points3d(s)