Suppose I have a cone of evenly distributed points starting at (0,0,0) and with its main axes along (0,0,1). I need to create a python script that rotates all points, so the cone is parallel to (1,1,1). What is the easiest way to to this using spherical coordinates?
For now, I've been transforming my spherical coordinates to cartesian ones, applying Rodrigue's formula and finally transforming the coordinates back again to spherical. But there should be an easier way, right?
Related
As the title states, I need to make a plane above a 3D dataset in Python. There should be no data points above such plane, and the distances between the plane and the dataset should be optimized such that the plane somehow generalizes the whole data.
this is the 3d surface plot
(this is another example) the plane should look like this
I've been stuck for months on how to start/approach this problem. Should I start looking for the maximums in the data? Should I start on finding the peak in the middle and tamper around the possible slopes of the plane? Or are there other appropriate mathematical methods for this?
Thanks ahead.
I am making maps of meteorological data (x,y-coordinates in m) using matplotlib.pyplot.contourf(). I want to plot a coastline, but all the examples I find on internet use lat-lon data (with cartopy or basemap).
Is there a way (without transforming the data to a lat-lon grid) to plot a coastline on my cartesian grid? I know size of the grid, and its center's lat-lon coordinates.
I haven't tried anything but look for similar examples, which I could not find.
The solution is to use cartopy's gnomonic projection: https://scitools.org.uk/cartopy/docs/v0.15/crs/projections.html#gnomonic , e.g.
proj =ccrs.Gnomonic(central_latitude=0, central_longitude= 0)
The origin of the data need to be specified (in lat-lon), and it expects the data coordinates to be distance in meters from that origin. Then, the normal cartopy features (like coastlines) work as usual.
Well, the problem I have is the following one.
I have data for axis X, Y and Z, and I want to plot the surface. For that I first interpolate/extrapolate to get , more mesh points and then I plot the surface (in Python) with plot_surface() function and I get it.
Later I have to use those points that I have for the mesh (already interpolated) as input in another function. As output I want the new surface and get it. But how can I get the coordinates of every point of that surface? As if I pointed with the cursor at that point.
I have to interpolate again?
Or there is other way?
I'd like to draw a 2D time series in color with flutter.
Goal
Obviously, it's different from 1D data in that along the y-axis I have a vector of discrete data points at each x, but the color graph must be continuous. So I'd love to use color gradients between these data points to present a continuous heat map.
The end result would look like a spectrogram
With Python's matplotlib, this would be a simple imshow() call.
Reference
From this question: How to do a Gradient effect from topLeft to botttomRgiht in Flutter Shader?
I learned that I could use flutter's shader to create color gradients. That's fine.
Problem
But it seems to me that I would need hundreds of shaders between the data points in order to draw dynamic gradients I want. The y-vector could be as big as 1000 to 2000 data points at each moment.
Is there a simpler way to achieve what I want, such as using as few shaders as possible?
I have data points in x,y,z format. They form a point cloud of a closed manifold. How can I interpolate them using R-Project or Python? (Like polynomial splines)
It depends on what the points originally represented. Just having an array of points is generally not enough to derive the original manifold from. You need to know which points go together.
The most common low-level boundary representation ("brep") is a bunch of triangles. This is e.g. what OpenGL and Directx get as input. I've written a Python software that can convert triangular meshes in STL format to e.g. a PDF image. Maybe you can adapt that to for your purpose. Interpolating a triangle is usually not necessary, but rather trivail to do. Create three new points each halfway between two original point. These three points form an inner triangle, and the rest of the surface forms three triangles. So with this you have transformed one triangle into four triangles.
If the points are control points for spline surface patches (like NURBS, or Bézier surfaces), you have to know which points together form a patch. Since these are parametric surfaces, once you know the control points, all the points on the surface can be determined. Below is the function for a Bézier surface. The parameters u and v are the the parametric coordinates of the surface. They run from 0 to 1 along two adjecent edges of the patch. The control points are k_ij.
The B functions are weight functions for each control point;
Suppose you want to approximate a Bézier surface by a grid of 10x10 points. To do that you have to evaluate the function p for u and v running from 0 to 1 in 10 steps (generating the steps is easily done with numpy.linspace).
For each (u,v) pair, p returns a 3D point.
If you want to visualise these points, you could use mplot3d from matplotlib.
By "compact manifold" do you mean a lower dimensional function like a trajectory or a surface that is embedded in 3d? You have several alternatives for the surface-problem in R depending on how "parametric" or "non-parametric" you want to be. Regression splines of various sorts could be applied within the framework of estimating mean f(x,y) and if these values were "tightly" spaced you may get a relatively accurate and simple summary estimate. There are several non-parametric methods such as found in packages 'locfit', 'akima' and 'mgcv'. (I'm not really sure how I would go about statistically estimating a 1-d manifold in 3-space.)
Edit: But if I did want to see a 3D distribution and get an idea of whether is was a parametric curve or trajectory, I would reach for package:rgl and just plot it in a rotatable 3D frame.
If you are instead trying to form the convex hull (for which the word interpolate is probably the wrong choice), then I know there are 2-d solutions and suspect that searching would find 3-d solutions as well. Constructing the right search strategy will depend on specifics whose absence the 2 comments so far reflects. I'm speculating that attempting to model lower and higher order statistics like the 1st and 99th percentile as a function of (x,y) could be attempted if you wanted to use a regression effort to create boundaries. There is a quantile regression package, 'rq' by Roger Koenker that is well supported.