I've been trying to draw a list of points in a 3D cartesian system with no avail.
I played around with plot3d, draw3d, wxdraw3d, and reading the doc gave me the impression draw3d should be the right choice.
However, a first attempt failed with error
3D graphic object not recognized
which I thought might be because the list consisted of vectors (coming from a previous matrix operation), so I've tried converting each single element into a sub-list
with list_matrix_entries, still to receive the same error.
What am I missing here? What is the right way to draw a three-dimensional cartesian system and a set of points into it?
You are using a variable name points that is a name of function.
load(draw);
pts:[[1,1,1],[1,2,2],[1,3,2],[1,4,3]];
scene:points(pts);
draw3d(scene);
Related
I am creating a line from point shapefile which is auto generated. First time when I create that line in ArcGIS, I got a line like this because the points are not in a order:
after that I ordered the points according to it's location and got a line like this:
But unable to create a line like this:
Please give me any solution to fix this in ArcGIS or R programming. If you need the shapefile I can provide you.
I think there is no bullet proof way to restore the line, as same dataset can obviously represent different lines, so you would need to use some heuristics to do this. What Rafael described is very good top-bottom heuristics if you can reliably detect start and end points.
Another heuristics could be a bottom-up process to stitch nearby segments into a line. Find nearby points for every point, sort and connect the two nearest points. Continue this process, making sure each point has at most two connections, and that there are no loops.
A simpler approach that might just work if the line follows in general some direction is your idea of sorting points. But instead of ordering by x or y coordinate, find a linear approximation of these points, project each point to this straight line, and sort using the coordinate of the projection.
One way to go about this would be to treat it as a graph problem.
Create a weighted fully connected graph where the nodes are the points and the edge weight distance between its endpoints. Heuristically identify the “starting” and “ending” points of the line (for example, pick the bottom-leftmost point as start and top-rightmost and end).
Then you can use a shortest path algorithm to generate the order in which you connect the points.
I have a GPX file with locations and altitude data.
I would like to create a 3D model and show this model using SceneKit.
I already tried the method using a NSBezierPath, but the problem is, that I can not add the Z data and it is more like a 2D route.
Right now I am creating a SCNBox for every single trackpoint - well, it works but it's not really that pretty and it kinda seems wrong.
I also thought about creating a 3D model (obj file) programatically, but this is too hard.
So, long story short: What is the best way to create a 3D geometry object with SceneKit when I got a list of points with X/Y/Z data?
Is there a way to "connect" SCNBoxes?
Regards,
Sascha
Try the SCNShape class. It allows you to create a 3D shape following a bezier path while controlling the Z axis as well:
"SceneKit creates a three-dimensional geometry by extruding a Bézier path, which extends in the x- and y-axis directions of its local coordinate space, along the z-axis by a specified amount."
I'm working on a PyMEL script that allows the user to duplicate a selected object multiple times, using a CV curve and its points coordinates to transform & rotate each copy to a certain point in space.
In order to achieve this, Im using the adjacent 2 points of each CV (control vertex) to determine the rotation for the object.
I have managed to retrieve the coordinates of the curve's CVs
#Add all points of the curve to the cvDict dictionary
int=0
cvDict={}
while int<selSize:
pointName='point%s' % int
coords= pointPosition ('%s.cv[%s]' % (obj,int), w=1)
#Setup the key for the current point
cvDict[pointName]={}
#add coords to x,y,z subkeys to dict
cvDict[pointName]['x']= coords[0]
cvDict[pointName]['y']= coords[1]
cvDict[pointName]['z']= coords[2]
int += 1
Now the problem I'm having is figuring out how to get the angle for each CV.
I stumbled upon the angleBetween() function:
http://download.autodesk.com/us/maya/2010help/CommandsPython/angleBetween.html
In theory, this should be my solution, since I could find the "middle vector" (not sure if that's the mathematical term) of each of the curve's CVs (using the adjacent CVs' coordinates to find a fourth point) and use the above mentioned function to determine how much I'd have to rotate the object using a reference vector, for example on the z axis.
At least theoretically - the issue is that the function only takes 1 set of coords for each vector and I have absolutely no Idea how to convert my point coords to that format (since I always have at least 2 sets of coordinates, one for each point).
Thanks.
If you wanna go the long way and not grab the world transforms of the curve, definitely make use of pymel's datatypes module. It has everything that python's native math module does and a few others that are Maya specific. Also the math you would require to do this based on CVs can be found here.
Hope that puts you in the right direction.
If you're going to skip the math, maybe you should just create a locator, path-animate it along the curve, and then sample the result. That would allow you to get completely continuous orientations along the curve. The midpoint-constraint method you've outlined above is limited to 1 valid sample per curve segment -- if you wanted 1/4 of the way or 3/4 of the way between two cv's your orientation would be off. Plus you don't have to reinvent all of the manu different options for deciding on the secondary axis of rotation, reading curves with funky parameterization, and so forth.
What is a good way to determine the points in the boundary of a given region in 2D?
Suppose that you are given a nested list with lists of two coordinates, e.g.
{ {x1,y1}, {x2,y2}, {x3,y3} }
Of course the actual nested list would have a lot more points than 3, which are associated to a given region in the plane. The nested list, for example, could determine a disk in the plane. Then, the output should be a nested list corresponding to a circle.
I don't want any image recognition stuff applied to a possible plot. I would like operations on the nested list.
This answer is based on #andand comment. The credit is all his.
If I have a nested list called "region", with lists of the 2d coordinates, I would get the "convex hull" of it writing
Needs["ComputationalGeometry`"]
regionhull = ConvexHull[ region ]
But "ConvexHull" gives us the indices of the lists within the nested list, in counterclockwise order, corresponding to the convex boundary of the region. Thus, an adittional step is needed, to make the needed output:
regionboundary = region[[ regionhull ]]
But still, this answer is incomplete. It seems to me that a "concave hull" algorithm would be the more general solution. Would anyone know anything about the concave hull in Mathematica? I may post an additional question for that.
Below, I show a figure to understand the concave and convex hull algorithms extracted from
https://gis.stackexchange.com/questions/1200/concave-hull-definition-algorithms-and-practical-solutions
A tutorial for the "Computational Geometry Package" is found at
http://reference.wolfram.com/mathematica/ComputationalGeometry/tutorial/ComputationalGeometry.html
** Addendum **
The package "alphahull" can solve the problem of finding the boundary of a concave region. Its description is found here:
http://cran.r-project.org/web/packages/alphahull/vignettes/alphahull.pdf
Sounds like you want some kind of interpolation technique. http://en.wikipedia.org/wiki/Interpolation
I've got data representing 3D surfaces (i.e. earthquake fault planes) in xyz point format. I'd like to create a 3D representation of these surfaces. I've had some success using rgl and akima, however it can't really handle geometry that may fold back on itself or have multiple z values at the same x,y point. Alternatively, using geometry (the convhulln function from qhull) I can create convex hulls that show up nicely in rgl but these are closed surfaces where in reality, the objects are open (don't completely enclose the point set). Is there a way to create these surfaces and render them, preferably in rgl?
EDIT
To clarify, the points are in a point cloud that defines the surface. They have varying density of coverage across the surface. However, the main issue is that the surface is one-sided, not closed, and I don't know how to generate a mesh/surface that isn't closed for more complex geometry.
As an example...
require(rgl)
require(akima)
faultdata<-cbind(c(1,1,1,2,2,2),c(1,1,1,2,2,2),c(10,20,-10,10,20,-10))
x <- faultdata[,1]
y <- faultdata[,2]
z <- faultdata[,3]
s <- interp(x,z,y,duplicate="strip")
surface3d(s$x,s$y,s$z,col=a,add=T)
This creates generally what I want. However, for planes that are more complex this doesn't necessarily work. e.g. where the data are:
faultdata<-cbind(c(2,2,2,2,2,2),c(1,1,1,2,2,2),c(10,20,-10,10,20,-10))
I can't use this approach because the points are all vertically co-planar. I also can't use convhulln because of the same issue and in general I don't want a closed hull, I want a surface. I looked at alphashape3d and it looks promising, but I'm not sure how to go about using it for this problem.
How do you determine how the points are connected together as a surface? By distance? That can be one way, and the alphashape3d package might be of use. Otherwise, if you know exactly how they are to be connected, then you can visualize it directly with rgl structures.