GPS to spherical coordinates with Vec3D & toxilibs

Re: GPS to spherical coordinates with Vec3D & toxilibs

2 years ago

Thanks Karsten! I will look into it asap...

http://postspectacular.com | http://toxiclibs.org

Re: GPS to spherical coordinates with Vec3D & toxilibs

2 years ago

Hi Karsten, et al...

I'm still a little lost. Haven't invested the time into setting up a project in Eclipse yet, but I did browse the source, and it does make sense, in a more concise way than the code I had taken from Jer.

That being said, I took the computePosOnSphere() function from your source, and it's giving me very different results (which... is expected, seeing as how it is a different function...

)

public Vec3D computePosOnSphere(int globeRadius) {
// build a spherical position from lat/lon and convert into XYZ space
pos = new Vec3D(globeRadius, MathUtils.radians(currentLongitude) + MathUtils.PI,
MathUtils.radians(currentLatitude)).toCartesian();
return pos;
}

(which returns {x:-118.39131, y:158.68607, z:-28.32369} ) draws the Green line,

and the old code, which I took from Jer's example

Vec3D latToSphere(Vec2D ll, float r) {
Vec3D v = new Vec3D();
ll = toRadians(ll.x, ll.y);
v.x = ll.x;
v.y = ll.y - PI/2;
v.z = r;
return(v);
};

(which returns {x:-1.8056206, y:-0.91642433, z:200.0}} ) draws the Blue line, (once the x and y are multiplied by the globe radius)

(see attached image)

Now, I still haven't put a texture on this example, but the Blue line is looking closer to being positioned at Berlin, at least after I noticed that for some reason in Jer's example that this function

Vec2D toRadians(float lat, float lon) {
Vec2D r = new Vec2D();
r.x = degreesToRadians(-lon) - PI/2;
r.y = degreesToRadians(-lat) + PI/2;
return(r);
};

had the y feeding the longitude calculation and the x feeding the latitude, which seemed inverted, so I switched them...

Still playing around with this, as you can see, but open to thoughts & suggestions... thanks.

~ J

toxmeister

Re: GPS to spherical coordinates with Vec3D & toxilibs

2 years ago

Sorry, Jesse, don't have time to look into detailed reasons WHY your current approach fails. But I'd simply guess that there's something fishy about your current toRadians() method. I.e. I don't understand why you're using the negative latitude:

r.y = degreesToRadians(-lat) + PI/2;

Obviously Jer had his reasons, but it might simply be to accomodate his texture settings. If you rotate the globe 180 degrees around X you might say the green line is the correct one... But as I said for time reasons, I know my method works correctly & would encourage to use this one instead. There's no need to "setup" a project in Eclipse, the vam-compdes-day7 example above already is a completely configured project, just need to import it in Eclipse:

File > Import... > General > Existing projects into Workspace...

Choose the downloaded zip file or already unzipped project folder

Press Finish

Now the project should appear in your Package explorer

Open the src folder and within it the "vamworkshop" package

Open GPSFlickrApp and paste your Flickr API key into this line:

private static final String FLICKR_API_KEY = "put your api key here"; // line 96

If you don't have a flickr API key yet, either create one here (only takes a few seconds) or comment out the call to initFlickr() in the setup() function and use the dummyImages() function instead (which will create random lat/lon locations)

Save, then right click on GPSFlickrApp.java and choose "Run As > Java Application"

Here's also another screenshot using Berlin's GPS loc: lon=13.3978, lat=52.5329

Q.E.D. :)

Re: GPS to spherical coordinates with Vec3D & toxilibs

2 years ago

Hi Karsten,

Ok, I just got the project opened, working with a Flicker key, and go the same result as you when setting the dummy gps to Berlin... so thanks for that, really. I know it works, and will look into what is going on a bit more... thanks!

Re: GPS to spherical coordinates with Vec3D & toxilibs

2 years ago

Hi Karsten, et al...

I got it working!

I slowly deconstructed your Eclipse project into a PDE version, using my own globe construction, recreated the functions, etc.. and was able to get the correct result...

The functions ended up looking like this

Vec2D gps;
Vec3D pos;
public void setLatLon() {
gps = new Vec2D(currentLongitude, currentLatitude);
}
public Vec3D computePosOnSphere(int globeRadius) {
pos = new Vec3D(globeRadius, MathUtils.radians(gps.x) + MathUtils.PI,MathUtils.radians(gps.y)).toCartesian();
return pos;
}
public void callPos() {
setLatLon();
computePosOnSphere(globeRadius);
}

and I've also ported this over onto Android, (you'll be happy to know that every toxilibs sketch i've ever tried to run on Android works perfectly...

) on top of some edits to the Earth example included in 0194, (which was ported by Andres, cleaned up by Aaron Koblin, coded by Mike Chang, and initially based on code by you, or so the credits say!

) and plugged the Lat/Lon into the GPS provider on the phone - and made the rotation controlled by the accelerometer and added a multitouch pinch/zoom - and it works perfectly there, as well.

Screenshots below:

Desktop

Phone:

So thanks again!

I'm going to be writing a little tutorial/example about this, as well as putting all the pieces together on Android, so I will post that when it's done...

cheers,

~ J

jimthree

Re: GPS to spherical coordinates with Vec3D & toxilibs

2 years ago

great thread, very useful. Jesse, i'd be very interested to see your write up and source for this. I am facing simillar issues rendering visitors to our websites on a globe.

Jim

Re: GPS to spherical coordinates with Vec3D & toxilibs

1 year ago

Hello,

1. Jesse would it be possible to take a look at your code somehow? Did you write that tutorial?

2. I'm wondering if the last update of toxiclibs, caused that the eclipse code is not porting right to PDE: I'm just getting a blue Sphere if I copy-paste the code from eclipse and make the most basic corrections so it works in PDE(See picture at the end). Printing pictures or boxes is working... just the texture is gone

I still cannot figure out if it has to do with the following error, and first thought the toxiclibs enclosed in that .zip should have been outdated (but the date of creation of the library files tell me they should be the last build):

"The method texturedMesh(TriangleMesh, PImage, boolean) ... is not applicable for the arguments (Mesh3D, PImage, boolean)"

My solution was to cast the globe mesh into a TriangleMesh and test. And I got the blue sphere.

...

TriangleMesh tm = (TriangleMesh)globe;

gfx.texturedMesh(tm, earthTex, true);

...

I tried doing it in setup, thinking it had to do something with the computeVertexNormals(method), but nothing changed.

Not important but interesting, there's another method called in the GPSPhoto class that is also non-existent in ToxicLibsSupport but works in the eclipse method:

gfx.fill(TColor.newRGB(1, 0, 0));

May be there's a simple thing I'm overseeing and I feel like going back to match the image-printing code with that textured-sphere code quoted by Jesse, but since I like the simplicity of using toxiclibs to generate the Textured sphere, I post wondering if you people receive updates on this and might help.

What I've got in case it makes things easier (I took all the flickr stuff out):

import processing.opengl.*;
import java.util.Date;
import java.util.LinkedList;
import java.util.List;
import toxi.color.*;
import toxi.color.theory.*;
import toxi.processing.*;
import toxi.geom.*;
import toxi.math.*;
import toxi.geom.mesh.subdiv.*;
import toxi.geom.mesh.*;
import toxi.geom.Vec3D;
/**
*
* This example is building on an exercise done at the V&A Computational Design
* workshop (Feb/Mar 2011)
*
*
*
* Here we demonstrate the use of the Flickrj library in conjunction with
* toxiclibs & Processing to produce a simple mapping visualization of geotagged
* images. The images are retrieved via several search terms (tags, time span
* and GPS bounding box). Furthermore, the basic principle of combining 2D & 3D
* coordinate systems and visibility checking of objects is shown too.
*
*
*
* IMPORTANT NOTE: Before running this example, please put your Flickr API key
* into the FLICKR_API_KEY constant.
*
*
*
* Usage:
* <ul>
* <li>Move mouse to rotate view</li>
* <li>Press '-' / '=' to adjust zoom</li>
* </ul>
*
*/
/**
* Max number of images to request from flickr
*/
private static final int MAX_IMAGES = 50;
/**
* Number of milliseconds per day
*/
private static final int DAY_DURATION = 24 * 60 * 60 * 1000;
/**
* Radius of our globe
*/
private static final int EARTH_RADIUS = 300;
/**
* Image size in pixels for rendering
*/
private static final int IMG_SIZE = 32;
/**
* Flickr API key
*/
private static final String FLICKR_API_KEY = "put your API key in here";
/**
/**
* List of geotagged images
*/
List<GPSPhoto> images = new LinkedList<GPSPhoto>();
/**
* Earth texture image
*/
private PImage earthTex;
/**
* Globe mesh
*/
private Mesh3D globe;
/**
* Toxiclibs helper class for rendering
*/
private ToxiclibsSupport gfx;
/**
* Camera rotation vector
*/
private final Vec3D camRot = new Vec3D();
/**
* Zoom factors
*/
private float currZoom = 1;
private float targetZoom = 1;
/**
* Render flag to show/hide labels
*/
private boolean showLabels = true;
public void setup() {
size(1024, 768, OPENGL);
// load tagged images from flickr uploaded in the past x days...
// initFlickr(new String[] {"color"}, MAX_IMAGES, 7 * DAY_DURATION);
// ...or create dummy images (in case there's no flickr available)
dummyImages(50);
// load earth texture image
earthTex = loadImage("/Users/protonumerique/Documents/projects/satellistica/PROCESS/vam-compdes-day7-4bf0efbaa8cd/earth_4096.jpg");
// build a sphere mesh with texture coordinates
// sphere resolution set to 36 vertices
globe = new SurfaceMeshBuilder(new SphereFunction()).createMesh(null,
36, EARTH_RADIUS);
// compute surface orientation vectors for each mesh vertex
// this is important for lighting calculations when rendering the mesh
globe.computeVertexNormals();
// setup helper class (assign to work with this applet)
gfx = new ToxiclibsSupport(this);
textFont(createFont("SansSerif", 10));
}
public void draw() {
// smoothly interpolate camera rotation
// to new rotation vector based on mouse position
// each frame we only approach that rotation by 25% (0.25 value)
camRot.interpolateToSelf(new Vec3D(mouseY * 0.01f, mouseX * 0.01f, 0),
0.25f / currZoom);
// smoothly update zoom as well
currZoom += (targetZoom - currZoom) * 0.25;
background(0);
lights();
// store default 2D coordinate system
pushMatrix();
// switch to 3D coordinate system and rotate view based on mouse
translate(width / 2, height / 2, 0);
rotateX(camRot.x);
rotateY(camRot.y);
// apply zoom factor
scale(currZoom);
// compute the normalized camera position/direction
// using the same rotation setting as for the coordinate system
// this vector is used to figure out if images are visible or not
// (see below)
Vec3D camPos = new Vec3D(0, 0, 1).rotateX(camRot.x).rotateY(camRot.y);
camPos.normalize();
noStroke();
fill(255);
// use normalized UV texture coordinates (range 0.0 ... 1.0)
textureMode(NORMAL);
// draw earth
TriangleMesh tm = (TriangleMesh)globe;
gfx.texturedMesh(tm, earthTex, true);
for (GPSPhoto img : images) {
// img.drawAsBox(gfx);
// compute 2D screen position and check visibility
img.updateScreenPos(this, camPos);
}
// switch back to 2D coordinate system
popMatrix();
// disable depth testing to ensure anything drawn next
// will always be on top/infront of the globe
hint(DISABLE_DEPTH_TEST);
// draw images centred around the given positions
imageMode(CENTER);
for (GPSPhoto img : images) {
img.drawAsImage(this, IMG_SIZE * currZoom * 0.9f, showLabels);
}
// restore (default) depth testing
hint(ENABLE_DEPTH_TEST);
}
/**
* Create dummy images
*/
void dummyImages(int num) {
for (int i = 0; i < num; i++) {
GPSPhoto gps = new GPSPhoto(loadImage("/Users/protonumerique/Documents/projects/satellistica/PROCESS/vam-compdes-day7-4bf0efbaa8cd/toxi.jpg"));
gps.setRandomLatLon();
gps.computePosOnSphere(EARTH_RADIUS);
images.add(gps);
}
}
public void keyPressed() {
if (key == '-') {
targetZoom = max(targetZoom - 0.1f, 0.5f);
}
if (key == '=') {
targetZoom = min(targetZoom + 0.1f, 1.9f);
}
if (key == 'l') {
showLabels = !showLabels;
}
}
public class GPSPhoto {
public PImage jpg;
Vec2D gps;
Vec3D pos;
Vec2D screenPos = new Vec2D();
boolean isVisible;
public GPSPhoto( PImage jpg) {
this.jpg = jpg;
// try to use actual flickr data
setRandomLatLon();
}
/**
* Computes the position of the image on a sphere of the given radius.
*
* @param earthRadius
* @return position in cartesian space
*/
public Vec3D computePosOnSphere(int earthRadius) {
// build a spherical position from lat/lon and convert into XYZ space
pos = new Vec3D(earthRadius, MathUtils.radians(gps.x) + MathUtils.PI,
MathUtils.radians(gps.y)).toCartesian();
return pos;
}
/**
* Draw a box on the sphere surface.
*
* @param gfx
*/
public void drawAsBox(ToxiclibsSupport gfx) {
// AABB = axis-aligned bounding box
//gfx.fill(TColor.newRGB(1, 0, 0));
gfx.box(new AABB(pos, 2));
}
/**
* Draws image at computed position in space.
*
* @param app
* parent applet
* @param size
* image size
* @param showLabel
* true, to draw image label
*/
public void drawAsImage(PApplet app, float size, boolean showLabel) {
// because this GPSPhoto class has no relation to PApplet
// we need to pass in our applet as parameter in order
// to utilize Processing functionality
if (isVisible) {
app.image(jpg, screenPos.x, screenPos.y, size, size);
}
}
public void setRandomLatLon() {
// random GPS location for testing
this.gps = new Vec2D(MathUtils.random(-180, 180), MathUtils.random(-90,
90));
// set to london
// this.gps = new Vec2D(0,51.1f);
}
public void updateScreenPos(PApplet app, Vec3D camPos) {
screenPos.set(app.screenX(pos.x, pos.y, pos.z),
app.screenY(pos.x, pos.y, pos.z));
// the dot product between 2 normalized vectors is an indication
// how closely aligned those 2 directions are
// if the result is >0.5 then the angle between the vectors
// is less than 90 degrees...
// here we check the difference between (normalized) camera position
// and the position of our image
// we use this as a tool to hide images if they are on the
// back side of the currently visible globe section
// the isVisible flag is used below in drawAsImage()
float dot = pos.getNormalized().dot(camPos);
isVisible = dot > 0.66;
}
}

Re: GPS to spherical coordinates with Vec3D & toxilibs

1 year ago

Hey...

No, I never wrote the tutorial - I was with Cedric at Onformative while we were working at this, but never pushed it any farther, so it wasn't quite interesting enough at the time...

But here is the code - I basically took the Earth example that you can find under the OPENGL examples in Android Mode, and made it all work with that...

Here's the Code - haven't really looked at it for a while, and not a lot of comments, but you're welcome to it!

import processing.opengl.*;
import toxi.geom.*;
import java.awt.event.*;
import toxi.geom.Vec2D;
import toxi.geom.Vec3D;
import toxi.math.MathUtils;
PImage texmap;
int sDetail = 32;
float rotationY = 0;
int globeRadius = 150;
float[] cx, cz, sphereX, sphereY, sphereZ;
float sinLUT[];
float cosLUT[];
float SINCOS_PRECISION = 0.5f;
int SINCOS_LENGTH = (int)(360.0f / SINCOS_PRECISION);
float currentLatitude = 52.507244;
float currentLongitude = 13.454436;
float zoom = -200;
float y = 0;
private final Vec3D camRot = new Vec3D();
private float currZoom = 1;
// ---------------------------------
public void setup() {
size(480, 800, OPENGL);
addMouseWheelListener(new MouseWheelInput());
texmap = loadImage("earth2.jpg");
initializeSphere(sDetail);
noStroke();
}
// ---------------------------------
public void draw() {
background(#d2c09c);
background(0,0,10);
zoom = y * 5;
renderGlobe();
}
// ---------------------------------
class MouseWheelInput implements MouseWheelListener {
void mouseWheelMoved(MouseWheelEvent e) {
int step=e.getWheelRotation();
y=y+step*5;
}
}
// ---------------------------------
Vec2D gps;
Vec3D pos;
public void setLatLon() {
// set to Berlin
gps = new Vec2D(13.3978, 52.5329);
}
public Vec3D computePosOnSphere(int globeRadius) {
pos = new Vec3D(globeRadius, MathUtils.radians(gps.x) + MathUtils.PI,MathUtils.radians(gps.y)).toCartesian();
return pos;
}
public void callPos() {
setLatLon();
computePosOnSphere(globeRadius);
}
// ---------------------------------
void keyPressed() {
saveFrame("save.jpg");
}
public void renderGlobe() {
callPos();
pushMatrix();
translate(width/2, height/2, zoom);
rotateY(rotationY);
rotateX(mouseY * 0.01f);
beginShape();
lights();
noStroke();
texturedSphere(globeRadius, texmap);
endShape();
strokeWeight(3);
stroke(0, 255, 155);
point(-pos.x, -pos.y, pos.z);
line(0, 0, 0, -pos.x, -pos.y, pos.z);
popMatrix();
rotationY -= 0.01;
}
// ---------------------------------
public void initializeSphere(int res) {
sinLUT = new float[SINCOS_LENGTH];
cosLUT = new float[SINCOS_LENGTH];
for (int i = 0; i < SINCOS_LENGTH; i++) {
sinLUT[i] = (float) Math.sin(i * DEG_TO_RAD * SINCOS_PRECISION);
cosLUT[i] = (float) Math.cos(i * DEG_TO_RAD * SINCOS_PRECISION);
}
float delta = (float)SINCOS_LENGTH/res;
float[] cx = new float[res];
float[] cz = new float[res];
// Calc unit circle in XZ plane
for (int i = 0; i < res; i++) {
cx[i] = -cosLUT[(int) (i*delta) % SINCOS_LENGTH];
cz[i] = sinLUT[(int) (i*delta) % SINCOS_LENGTH];
}
// Computing vertexlist vertexlist starts at south pole
int vertCount = res * (res-1) + 2;
int currVert = 0;
// Re-init arrays to store vertices
sphereX = new float[vertCount];
sphereY = new float[vertCount];
sphereZ = new float[vertCount];
float angle_step = (SINCOS_LENGTH*0.5f)/res;
float angle = angle_step;
// Step along Y axis
for (int i = 1; i < res; i++) {
float curradius = sinLUT[(int) angle % SINCOS_LENGTH];
float currY = -cosLUT[(int) angle % SINCOS_LENGTH];
for (int j = 0; j < res; j++) {
sphereX[currVert] = cx[j] * curradius;
sphereY[currVert] = currY;
sphereZ[currVert++] = cz[j] * curradius;
}
angle += angle_step;
}
sDetail = res;
}
// Generic routine to draw textured sphere
void texturedSphere(float r, PImage t) {
int v1,v11,v2;
r = (r + 240 ) * 0.33;
beginShape(TRIANGLE_STRIP);
texture(t);
float iu=(float)(t.width-1)/(sDetail);
float iv=(float)(t.height-1)/(sDetail);
float u=0,v=iv;
for (int i = 0; i < sDetail; i++) {
normal(0, -1, 0);
vertex(0, -r, 0,u,0);
normal(sphereX[i], sphereY[i], sphereZ[i]);
vertex(sphereX[i]*r, sphereY[i]*r, sphereZ[i]*r, u, v);
u+=iu;
}
vertex(0, -r, 0,u,0);
normal(sphereX[0], sphereY[0], sphereZ[0]);
vertex(sphereX[0]*r, sphereY[0]*r, sphereZ[0]*r, u, v);
endShape();
// Middle rings
int voff = 0;
for(int i = 2; i < sDetail; i++) {
v1=v11=voff;
voff += sDetail;
v2=voff;
u=0;
beginShape(TRIANGLE_STRIP);
texture(t);
for (int j = 0; j < sDetail; j++) {
normal(sphereX[v1], sphereY[v1], sphereZ[v1]);
vertex(sphereX[v1]*r, sphereY[v1]*r, sphereZ[v1++]*r, u, v);
normal(sphereX[v2], sphereY[v2], sphereZ[v2]);
vertex(sphereX[v2]*r, sphereY[v2]*r, sphereZ[v2++]*r, u, v+iv);
u+=iu;
}
// Close each ring
v1=v11;
v2=voff;
normal(sphereX[v1], sphereY[v1], sphereZ[v1]);
vertex(sphereX[v1]*r, sphereY[v1]*r, sphereZ[v1]*r, u, v);
normal(sphereX[v2], sphereY[v2], sphereZ[v2]);
vertex(sphereX[v2]*r, sphereY[v2]*r, sphereZ[v2]*r, u, v+iv);
endShape();
v+=iv;
}
u=0;
// Add the northern cap
beginShape(TRIANGLE_STRIP);
texture(t);
for (int i = 0; i < sDetail; i++) {
v2 = voff + i;
normal(sphereX[v2], sphereY[v2], sphereZ[v2]);
vertex(sphereX[v2]*r, sphereY[v2]*r, sphereZ[v2]*r, u, v);
normal(0, 1, 0);
vertex(0, r, 0, u, v+iv);
u+=iu;
}
normal(sphereX[voff], sphereY[voff], sphereZ[voff]);
vertex(sphereX[voff]*r, sphereY[voff]*r, sphereZ[voff]*r, u, v);
endShape();
}

There's a few things in here like a scroll wheel listener for the zoom, etc. that you won't really need, but it's a nice effect!

This was made in 1.5.1, with toxiclibs v0020 (though may have been built with 0019, but it still works for me...)

Re: GPS to spherical coordinates with Vec3D & toxilibs

1 year ago

Sorry, I came to check very late, thinking that I was following this post. But got no email about your answer. Thanks a lot. Your code is working and helped to move on. Somehow I'd like to go on with toxi's solution just for the purpose of simplicity, but I'd rather not loose time trying to find out what is wrong. May be latr... cheers.

Btw, I shortened the code a bit and created classes so you can print different cities at once if you need. So I share it as a wrap-up:

import processing.opengl.*;
import toxi.geom.*;
import java.awt.event.*;
import toxi.geom.Vec2D;
import toxi.geom.Vec3D;
import toxi.math.MathUtils;
PImage texmap;
int sDetail = 36;
float EARTH_RADIUS = 300;
TexSphere earth;
SphericalCoordinate place;
float currentLatitude = 52.524268;
float currentLongitude = 13.40629;
float zoom = -200;
float y = 0;
private final Vec3D camRot = new Vec3D();
float rotationX = 0;
float rotationY = 0;
float velocityX = 0;
float velocityY = 0;
// ---------------------------------
public void setup() {
size(1280, 720, OPENGL);
addMouseWheelListener(new MouseWheelInput());
texmap = loadImage("earth2.jpg");
earth = new TexSphere(sDetail, EARTH_RADIUS, texmap);
earth.initializeSphere();
place = new SphericalCoordinate(currentLatitude, currentLongitude, EARTH_RADIUS);
noStroke();
}
// ---------------------------------
public void draw() {
background(0, 0, 10);
camRot.interpolateToSelf(new Vec3D(rotationX, rotationY, 0),
0.95f / 1);
zoom = y * 0.95;
renderGlobe();
rotationX += velocityX;
rotationY += velocityY;
velocityX *= 0.95;
velocityY *= 0.95;
if (mousePressed) {
velocityX += (mouseY-pmouseY) * 0.01;
velocityY -= (mouseX-pmouseX) * 0.01;
}
}
// ---------------------------------
class MouseWheelInput implements MouseWheelListener {
void mouseWheelMoved(MouseWheelEvent e) {
int step=e.getWheelRotation();
y=y+step*0.45;
}
}
// ---------------------------------
void keyPressed() {
saveFrame("save.jpg");
}
public void renderGlobe() {
Vec3D pos = place.getCartesianPos();
pushMatrix();
translate(width/2, height/2, zoom);
rotateX(camRot.x);
rotateY(camRot.y);
lights();
noStroke();
earth.texturedSphere();
strokeWeight(3);
stroke(0, 255, 155);
Vec3D dir = pos.getNormalized();
Vec3D skyPos = dir.scale(30);
pushMatrix();
translate(-pos.x, -pos.y, pos.z);
line(0, 0, 0, -skyPos.x, -skyPos.y, skyPos.z);
popMatrix();
popMatrix();
}
/*
* A class to store coordinates and process them
*/
class SphericalCoordinate {
Vec2D gps;
Vec3D pos;
float latitude, longitude;
public SphericalCoordinate(float lat, float lon, float r) {
setLatLon(lat, lon);
computePosOnSphere(r);
}
public void setLatLon(float lat, float lon) {
// set to Berlin
gps = new Vec2D(lon, lat);
}
public Vec3D computePosOnSphere(float globeRadius) {
pos = new Vec3D(globeRadius, MathUtils.radians(gps.x) + MathUtils.PI, MathUtils.radians(gps.y)).toCartesian();
return pos;
}
public Vec3D getCartesianPos() {
return pos;
}
}
/*
* The example- textured sphere
*/
class TexSphere {
float[] cx, cz, sphereX, sphereY, sphereZ;
float sinLUT[];
float cosLUT[];
float SINCOS_PRECISION = 0.5;
int SINCOS_LENGTH = int(360.0 / SINCOS_PRECISION);
int res;
float r;
PImage t;
public TexSphere(int rs, float ra, PImage tex) {
res = rs;
r = ra;
t= tex;
}
void initializeSphere()
{
sinLUT = new float[SINCOS_LENGTH];
cosLUT = new float[SINCOS_LENGTH];
for (int i = 0; i < SINCOS_LENGTH; i++) {
sinLUT[i] = (float) Math.sin(i * DEG_TO_RAD * SINCOS_PRECISION);
cosLUT[i] = (float) Math.cos(i * DEG_TO_RAD * SINCOS_PRECISION);
}
float delta = (float)SINCOS_LENGTH/res;
float[] cx = new float[res];
float[] cz = new float[res];
// Calc unit circle in XZ plane
for (int i = 0; i < res; i++) {
cx[i] = -cosLUT[(int) (i*delta) % SINCOS_LENGTH];
cz[i] = sinLUT[(int) (i*delta) % SINCOS_LENGTH];
}
// Computing vertexlist vertexlist starts at south pole
int vertCount = res * (res-1) + 2;
int currVert = 0;
// Re-init arrays to store vertices
sphereX = new float[vertCount];
sphereY = new float[vertCount];
sphereZ = new float[vertCount];
float angle_step = (SINCOS_LENGTH*0.5f)/res;
float angle = angle_step;
// Step along Y axis
for (int i = 1; i < res; i++) {
float curradius = sinLUT[(int) angle % SINCOS_LENGTH];
float currY = -cosLUT[(int) angle % SINCOS_LENGTH];
for (int j = 0; j < res; j++) {
sphereX[currVert] = cx[j] * curradius;
sphereY[currVert] = currY;
sphereZ[currVert++] = cz[j] * curradius;
}
angle += angle_step;
}
//sDetail = res;
}
// Generic routine to draw textured sphere
void texturedSphere()
{
int v1, v11, v2;
//r = (r + 240 ) * 0.5;
beginShape(TRIANGLE_STRIP);
texture(t);
float iu=(float)(t.width-1)/(res);
float iv=(float)(t.height-1)/(res);
float u=0, v=iv;
for (int i = 0; i < res; i++) {
vertex(0, -r, 0, u, 0);
vertex(sphereX[i]*r, sphereY[i]*r, sphereZ[i]*r, u, v);
u+=iu;
}
vertex(0, -r, 0, u, 0);
vertex(sphereX[0]*r, sphereY[0]*r, sphereZ[0]*r, u, v);
endShape();
// Middle rings
int voff = 0;
for (int i = 2; i < res; i++) {
v1=v11=voff;
voff += res;
v2=voff;
u=0;
beginShape(TRIANGLE_STRIP);
texture(t);
for (int j = 0; j < res; j++) {
vertex(sphereX[v1]*r, sphereY[v1]*r, sphereZ[v1++]*r, u, v);
vertex(sphereX[v2]*r, sphereY[v2]*r, sphereZ[v2++]*r, u, v+iv);
u+=iu;
}
// Close each ring
v1=v11;
v2=voff;
vertex(sphereX[v1]*r, sphereY[v1]*r, sphereZ[v1]*r, u, v);
vertex(sphereX[v2]*r, sphereY[v2]*r, sphereZ[v2]*r, u, v+iv);
endShape();
v+=iv;
}
u=0;
// Add the northern cap
beginShape(TRIANGLE_STRIP);
texture(t);
for (int i = 0; i < res; i++) {
v2 = voff + i;
vertex(sphereX[v2]*r, sphereY[v2]*r, sphereZ[v2]*r, u, v);
vertex(0, r, 0, u, v+iv);
u+=iu;
}
vertex(sphereX[voff]*r, sphereY[voff]*r, sphereZ[voff]*r, u, v);
endShape();
}
}

http://upload.wikimedia.org/wikipedia/commons/7/74/Mercator-projection.jpg

Re: GPS to spherical coordinates with Vec3D & toxilibs

11 months ago

could someone give the image of

earth2.jpg

i tried to use:

but when i give the lat and lon of the netherlands i end up in russia...

Re: GPS to spherical coordinates with Vec3D & toxilibs

11 months ago

I can package a list of images that work if you like...

Re: GPS to spherical coordinates with Vec3D & toxilibs

11 months ago

It should be inside the openGL example folder called texturedSphere. If you're on mac just need to right-click the processing app and select "view package contents", in order to get there

Re: GPS to spherical coordinates with Vec3D & toxilibs

8 months ago

this works correct for me:

Vec3D pos = new Vec3D(globeRadius+10, MathUtils.radians(5) + MathUtils.PI, MathUtils.radians(51)).toCartesian();
pushMatrix();
translate(-pos.x, -pos.y, pos.z);
fill(255, 0, 0);
box(9);
popMatrix();

It draws the position at Arnhem, the netherlands.

However, i want to do it with rotating the lat and long to get there.

I tried a lot of things like:

pushMatrix();
rotateX(-radians(51));
rotateX(-HALF_PI);
rotateY(radians(5));
translate(globeRadius, 0);
sphere(10);
popMatrix();
pushMatrix();
rotateX(radians(51));
rotateY(radians(5));
translate(globeRadius, 0);
box(10);
popMatrix();
pushMatrix();
rotateX(radians(5));
rotateY(radians(51));
translate(globeRadius, 0);
box(10);
popMatrix();
pushMatrix();
rotateX(radians(-5));
rotateY(radians(51));
translate(globeRadius, 0);
box(10);
popMatrix();
pushMatrix();
rotateX(radians(-5));
rotateY(radians(-51));
translate(globeRadius, 0);
box(10);
popMatrix();
pushMatrix();
rotateX(radians(5));
rotateY(radians(-51));
translate(globeRadius, 0);
box(10);
popMatrix();

Also from this topic:

(where i tried -lat etc.);

Vec2D toRadians(float lat, float lon) {
Vec2D r = new Vec2D();
r.x = degrees((lon) - PI/2);
r.y = degrees((lat) + PI/2);
return(r);
};

However, i can't get it correct.

Hope someone can help.

Re: [WatchList] GPS to spherical coordinates with Vec3D & toxilibs

8 months ago - via EMail-to-forum

I don't get what you mean by rotating: rotating the globe interactively so you get to see your marker, animating the rotation of the globe, or draw a path over the globe to go from one point to another?

Need to be describe your problem more precisely, else nobody will be able to help.

On Oct 1, 2012, at 12:23 PM, Processing Forum wrote:

Re: GPS to spherical coordinates with Vec3D & toxilibs

7 months ago

Ok, close to finsihing a project and still have the problem which is getting a big issue now.

I tried again to understand and did some new attempts but still no succes.

I try to explain it as clear as possible.

To begin:

In the sketches on the forum, why is longitude stored in x and latitude stored in y?

Cause if i look at the image below and the way processing rotates it makes more sense to switch it.

Cause to rotate to berlin for example i should rotate like 13 degrees in the y axis (lon) and 52 in the x axis (lat).

See:

-------------------------------

Then apart from that, this works correct:

Vec3D computePosOnSphere(int globeRadius) {
pos = new Vec3D(globeRadius, MathUtils.radians(gps.x) + MathUtils.PI,MathUtils.radians(gps.y)).toCartesian();
return pos;
}

But instead of that position i want to rotate so x is in the direction of that position.

rotateX(radians(gps.#));

rotateY(radians(gps.#));

So if i draw a line after the rotation it should be standing as a tangent on berlin.

In other words, the red line in the image below is wrong, it should be on the position of the green line:

Here is the code:

import processing.opengl.*;
import toxi.geom.*;
import java.awt.event.*;
import toxi.geom.Vec2D;
import toxi.geom.Vec3D;
import toxi.math.MathUtils;
import peasy.*;
PeasyCam cam;
PImage texmap;
int sDetail = 32;
int globeRadius = 150;
float[] cx, cz, sphereX, sphereY, sphereZ;
float sinLUT[];
float cosLUT[];
float SINCOS_PRECISION = 0.5f;
int SINCOS_LENGTH = (int)(360.0f / SINCOS_PRECISION);
float y = 0;
float[][] nukeData = new float[][] {
//{33.6753, -106.4747} ,
//{34.3914, 132.4581},
//{0, 0},
//{180, 0},
//{90, 0},
// berlin
{52, 13}
};
Nuke[] nukes;// = new Nuke[2];
// ---------------------------------
void setup() {
size(720, 560, OPENGL);
texmap = loadImage("earth2.jpg");
initializeSphere(sDetail);
noStroke();
cam = new PeasyCam(this, 400);
nukes = new Nuke[nukeData.length];
for(int i = 0; i < nukeData.length; i++) {
nukes[i] = new Nuke(nukeData[i][0], nukeData[i][1]);
}
// nukes[0] = new Nuke(33.6753, -106.4747);
// nukes[1] = new Nuke(34.3914, 132.4581);
}
// ---------------------------------
void draw() {
background(0);
// radius / texture
noStroke();
texturedSphere(globeRadius, texmap);
for (int i=0; i<nukes.length; i++) {
nukes[i].render();
}
}
// ---------------------------------
public void initializeSphere(int res) {
sinLUT = new float[SINCOS_LENGTH];
cosLUT = new float[SINCOS_LENGTH];
for (int i = 0; i < SINCOS_LENGTH; i++) {
sinLUT[i] = (float) Math.sin(i * DEG_TO_RAD * SINCOS_PRECISION);
cosLUT[i] = (float) Math.cos(i * DEG_TO_RAD * SINCOS_PRECISION);
}
float delta = (float)SINCOS_LENGTH/res;
float[] cx = new float[res];
float[] cz = new float[res];
// Calc unit circle in XZ plane
for (int i = 0; i < res; i++) {
cx[i] = -cosLUT[(int) (i*delta) % SINCOS_LENGTH];
cz[i] = sinLUT[(int) (i*delta) % SINCOS_LENGTH];
}
// Computing vertexlist vertexlist starts at south pole
int vertCount = res * (res-1) + 2;
int currVert = 0;
// Re-init arrays to store vertices
sphereX = new float[vertCount];
sphereY = new float[vertCount];
sphereZ = new float[vertCount];
float angle_step = (SINCOS_LENGTH*0.5f)/res;
float angle = angle_step;
// Step along Y axis
for (int i = 1; i < res; i++) {
float curradius = sinLUT[(int) angle % SINCOS_LENGTH];
float currY = -cosLUT[(int) angle % SINCOS_LENGTH];
for (int j = 0; j < res; j++) {
sphereX[currVert] = cx[j] * curradius;
sphereY[currVert] = currY;
sphereZ[currVert++] = cz[j] * curradius;
}
angle += angle_step;
}
sDetail = res;
}
// Generic routine to draw textured sphere
void texturedSphere(float r, PImage t) {
int v1,v11,v2;
r = (r + 240 ) * 0.33;
beginShape(TRIANGLE_STRIP);
texture(t);
float iu=(float)(t.width-1)/(sDetail);
float iv=(float)(t.height-1)/(sDetail);
float u=0,v=iv;
for (int i = 0; i < sDetail; i++) {
normal(0, -1, 0);
vertex(0, -r, 0,u,0);
normal(sphereX[i], sphereY[i], sphereZ[i]);
vertex(sphereX[i]*r, sphereY[i]*r, sphereZ[i]*r, u, v);
u+=iu;
}
vertex(0, -r, 0,u,0);
normal(sphereX[0], sphereY[0], sphereZ[0]);
vertex(sphereX[0]*r, sphereY[0]*r, sphereZ[0]*r, u, v);
endShape();
// Middle rings
int voff = 0;
for(int i = 2; i < sDetail; i++) {
v1=v11=voff;
voff += sDetail;
v2=voff;
u=0;
beginShape(TRIANGLE_STRIP);
texture(t);
for (int j = 0; j < sDetail; j++) {
normal(sphereX[v1], sphereY[v1], sphereZ[v1]);
vertex(sphereX[v1]*r, sphereY[v1]*r, sphereZ[v1++]*r, u, v);
normal(sphereX[v2], sphereY[v2], sphereZ[v2]);
vertex(sphereX[v2]*r, sphereY[v2]*r, sphereZ[v2++]*r, u, v+iv);
u+=iu;
}
// Close each ring
v1=v11;
v2=voff;
normal(sphereX[v1], sphereY[v1], sphereZ[v1]);
vertex(sphereX[v1]*r, sphereY[v1]*r, sphereZ[v1]*r, u, v);
normal(sphereX[v2], sphereY[v2], sphereZ[v2]);
vertex(sphereX[v2]*r, sphereY[v2]*r, sphereZ[v2]*r, u, v+iv);
endShape();
v+=iv;
}
u=0;
// Add the northern cap
beginShape(TRIANGLE_STRIP);
texture(t);
for (int i = 0; i < sDetail; i++) {
v2 = voff + i;
normal(sphereX[v2], sphereY[v2], sphereZ[v2]);
vertex(sphereX[v2]*r, sphereY[v2]*r, sphereZ[v2]*r, u, v);
normal(0, 1, 0);
vertex(0, r, 0, u, v+iv);
u+=iu;
}
normal(sphereX[voff], sphereY[voff], sphereZ[voff]);
vertex(sphereX[voff]*r, sphereY[voff]*r, sphereZ[voff]*r, u, v);
endShape();
}
class Nuke {
Vec2D gps;
Vec3D pos;
float lat;
float lon;
String country;
float x;
float y;
Nuke(float _lat, float _lon) {
lat = _lat;
lon = _lon;
gps = new Vec2D(lon,lat);
computePosOnSphere(globeRadius);
}
void render() {
// correct
strokeWeight(3);
stroke(0, 255, 155);
point(-pos.x, -pos.y, pos.z);
line(0, 0, 0, -pos.x, -pos.y, pos.z);
text(lat+" "+lon, -pos.x, -pos.y, pos.z);
// incorrect
// what i want is rotate
// so x is in the direction of gps target
strokeWeight(1);
stroke(255, 0, 0);
pushMatrix();
rotateX(radians(gps.x));
rotateY(radians(gps.y));
// rotateZ(-PI);
line(0, 0, 0, 200, 0, 0);
popMatrix();
}
Vec3D computePosOnSphere(int globeRadius) {
pos = new Vec3D(globeRadius, MathUtils.radians(gps.x) + MathUtils.PI,MathUtils.radians(gps.y)).toCartesian();
return pos;
}
}

Here is the image:

please help!

Re: GPS to spherical coordinates with Vec3D & toxilibs

7 months ago

Hi ClankillR,

Yeah, you're correct, I had the X/Y Lat/Lon mixed up...

Is that your only question ?

~ J

Re: GPS to spherical coordinates with Vec3D & toxilibs

7 months ago

Hi,

I guess Jesse's question points to: Clarify your question much more! But I tried to read between the lines: that red line you talk about must be perpendicular to the green line? Is that what you mean? Like a giant "T" coming out of Berlin? The inversion of Lat, Lon might make everything confusing, but it has nothing to do with that problem. At the end you're correctly setting your desired location on the Globe.

If you want to do the "T" thing, you need to find a Perpendicular Vector. Using rotate...() will just rotate the whole matrix and trace a new line from the origin to the point you specify. I'll recommend you to read a bit about vector math and about usind translate() on Processing.

Replace your Nuke class with this one (Actually just changed some lines in render()) and you'll get the "T". If it's not what you need, draw something and load it up!

class Nuke {
Vec2D gps;
Vec3D pos;
float lat;
float lon;
String country;

float x;
float y;

Nuke(float _lat, float _lon) {

    lat = _lat;
    lon = _lon;
    gps = new Vec2D(lon,lat);
    pos = computePosOnSphere(globeRadius);
}

void render() {

// correct? I don't know for real, but may be you get an idea?
strokeWeight(3);
stroke(0, 255, 155);
line(0, 0, 0, -pos.x, -pos.y, pos.z);
pushMatrix();
translate(-pos.x, -pos.y, pos.z);
Vec3D dir = pos.getNormalized();//Translate to the end of the original line
dir = dir.cross(new Vec3D (0,0,1));//Find cross product with another vector with a different direction to find a perpendicular vector.
Vec3D rotated = dir.scale(20);//Scale the cross product-Vector
stroke(255, 0, 0);
line(-rotated.x,-rotated.y,rotated.z,rotated.x,rotated.y,rotated.z);
popMatrix();
}

Vec3D computePosOnSphere(int globeRadius) {
    pos = new Vec3D(globeRadius, MathUtils.radians(gps.x) + MathUtils.PI,MathUtils.radians(gps.y)).toCartesian();
    return pos;
}
}

Re: GPS to spherical coordinates with Vec3D & toxilibs

7 months ago

no :)

To start with the method from toxi:

public Vec3D computePosOnSphere(float globeRadius) {
pos = new Vec3D(globeRadius, MathUtils.radians(gps.x) + MathUtils.PI, MathUtils.radians(gps.y)).toCartesian();
return pos;
}

how can x always be globeradius? This would mean it always goes the same amount to the right.

I saw toxi's thing worked and i wouldn't expect else from him but i just don't get it.

For me this makes more sense but i would like to understand toxi's thing.

Vec3D computePosOnSphere(float lat, float lon, float sphereRadius) {
float x = sphereRadius * cos(radians(lat)) * cos(radians(lon));
float y = sphereRadius * -sin(radians(lat));
float z = sphereRadius * cos(radians(lat)) * sin(radians(lon));
return new Vec3D(x, y, z);
}

For the rest, i'm still interested in getting the red line in the image in previous post on the position of the green line:

pushMatrix();
rotateX(radians(gps.x));
rotateY(radians(gps.y));
line(0, 0, 0, 200, 0, 0);
popMatrix();

But it seems like i'm facing gimball lock :(