C RUBY-ON-RAILS MYSQL ASP.NET DEVELOPMENT RUBY .NET LINUX SQL-SERVER REGEX WINDOWS ALGORITHM ECLIPSE VISUAL-STUDIO STRING SVN PERFORMANCE APACHE-FLEX UNIT-TESTING SECURITY LINQ UNIX MATH EMAIL OOP LANGUAGE-AGNOSTIC VB6 MSBUILD

# Iteratively position spheres with DOM pixels using three.js and React

## Iteratively position spheres with DOM pixels using three.js and React Tag : javascript , By : walshtp Date : November 28 2020, 04:01 AM

help you fix your problem Three.js uses lazy initialization for several things, including the camera system (projection matrix). That only gets fully initialized when you first render the scene.
When you calculate the position of the first planet, the scene has never been rendered before, so unproject from the "camera" perspective doesn't work as it should.
``````function initThree() {

....
// initialize camera
renderer.render(scene, camera);
}
``````

Share :

## position spheres along a bezier curve

Tag : math , By : arbeitandy
Date : March 29 2020, 07:55 AM
around this issue If your spheres are small enough relative to the overall length of the Bezier curve, you can just position your spheres at even intervals to get an appearance similar to a string of pearls. (If the spheres are relatively large then you'll have to start worrying about sphere overlap more -- not an easy problem, and probably not very instructive for learning OpenGL.)
The parameter value t of a Bezier curve varies from 0 to 1. To evaluate your Bezier curve at 10 locations (the ends and eight interior points) you can do something like this:
``````for( int i = 0; i <= 9; ++i )
{
double t = i / 9.0;
double x, y;
EvalBezier( t, x, y );
}
``````

## JOGL: Drawing spheres at specified position causes issues

Tag : java , By : KL.
Date : March 29 2020, 07:55 AM
I hope this helps you . I am trying to draw spheres in a 3D OpenGL canvas with JOGL using the following GLUT-Method: , A little bit of research revealed the answer:
the method
``````gl.glTranslate(posX,posY,posZ);
``````
``````gl.glLoadIdentity();
gl.glTranslate(posX,posY,posZ);
``````

## iteratively search and reclass pixels with smallest value in a raster

Tag : r , By : Bas
Date : March 29 2020, 07:55 AM
fixed the issue. Will look into that further Perhaps you can use the below. I would not try this on very large rasters (that will take forever). But for your example it works fine --- if you do not have to do this too many times.
``````library(raster)
set.seed(0)
xy <- matrix(rnorm(900, 40, 200),30 , 30)
r <- raster(xy)
extent(r) <- c(36,37,-3,-2)
rorig <- r
x <- r
i <- 1
while (TRUE) {
# cell with min value
m <- which.min(x)
## are there, and do you care about ties? Do they have the same level?
## If not, you can do
## m[1]
## or sample
## m <- sample(m, 1)
# focal and four adjacent cells
a <- adjacent(r, m, 4, FALSE, include=TRUE)
# exclude those that have already been affected
w <- which(!is.na(x[a]))
a <- a[w]
# assign the value
r[a] <- i
# set assigned cells to NA
x[a] <- NA
# stop when done
if (is.na(maxValue(x))) break
i <- i + 1
}

plot(r)
plot(rorig, r)
``````

## Calculating individual spheres position to create a sphere made of spheres

Tag : javascript , By : doctorbigtime
Date : March 29 2020, 07:55 AM
I wish did fix the issue. I would definitely say that this is a perfect use case of a physics engine. Making this simulation without a physics engine sounds like a real hassle, so "including an entire physics engine" doesn't seam like such a big cost to me. Most of the JavaScript physics engines that i've found are leight weight anyway. It will however demand some extra CPU power for the physics calculations!
I sat down and tried to create something similar to what you describe with the physics engine CANNON.js. It was quite easy to get a basic simulation working, but to get the parameters just right took is what seems a bit tricky, and will need more adjusting.
``````function pullOrigin(body){
body.force.set(
-body.position.x,
-body.position.y,
-body.position.z
);
}
``````
``````let scene = new THREE.Scene();
let world = new CANNON.World();
world.solver.iterations = 5;

let camera = new THREE.PerspectiveCamera( 75, window.innerWidth/window.innerHeight, 0.1, 1000 );

let renderer = new THREE.WebGLRenderer();
renderer.setSize( window.innerWidth, window.innerHeight );
document.body.appendChild( renderer.domElement );

function Proton(){

return {
// Cannon
body: new CANNON.Body({
mass: 1, // kg
position: randomPosition(6),
}),
// THREE
mesh: new THREE.Mesh(
new THREE.SphereGeometry( radius, 32, 32 ),
new THREE.MeshPhongMaterial( { color: 0xdd5555, specular: 0x999999, shininess: 13} )
)
}
}

function Neutron(){

return {
// Cannon
body: new CANNON.Body({
mass: 1, // kg
position: randomPosition(6),
}),
// THREE
mesh: new THREE.Mesh(
new THREE.SphereGeometry( radius, 32, 32 ),
new THREE.MeshPhongMaterial( { color: 0x55dddd, specular: 0x999999, shininess: 13} )
)
}
}

function Electron(){

return {
// Cannon
body: new CANNON.Body({
mass: 0.5, // kg
position: randomPosition(10),
}),
// THREE
mesh: new THREE.Mesh(
new THREE.SphereGeometry( radius, 32, 32 ),
new THREE.MeshPhongMaterial( { color: 0xdddd55, specular: 0x999999, shininess: 13} )
)
}
}

let x = (2 * Math.random() - 1 ) * outerRadius,
y = (2 * Math.random() - 1 ) * outerRadius,
z = (2 * Math.random() - 1 ) * outerRadius
return new CANNON.Vec3(x, y, z);
}

}

// create our Atom
let protons = Array(5).fill(0).map( () => Proton() );
let neutrons = Array(5).fill(0).map( () => Neutron() );
let electrons = Array(15).fill(0).map( () => Electron() );

let light = new THREE.AmbientLight( 0x202020 ); // soft white light

let directionalLight = new THREE.DirectionalLight( 0xffffff, 0.5 );
directionalLight.position.set( -1, 1, 1 );

camera.position.z = 18;

const timeStep = 1/60;

//Small impulse on the electrons to get them moving in the start
electrons.forEach((electron) => {
let centerDir = electron.body.position.vsub(new CANNON.Vec3(0, 0, 0));
centerDir.normalize();
let impulse = centerDir.cross(new CANNON.Vec3(0, 0, 1));
impulse.scale(2, impulse);
electron.body.applyLocalImpulse(impulse, new CANNON.Vec3(0, 0, 0));
});

function render () {
requestAnimationFrame( render );

// all particles pull towards the center
protons.forEach(pullOrigin);
neutrons.forEach(pullOrigin);
electrons.forEach(pullOrigin);

// electrons should also be pushed by protons and neutrons
electrons.forEach( (electron) => {
let pushForce = new CANNON.Vec3(0, 0, 0 );

protons.forEach((proton) => {
let f = electron.body.position.vsub(proton.body.position);
});

neutrons.forEach((neutron) => {
let f = electron.body.position.vsub(neutron.body.position);
});

pushForce.scale(0.07, pushForce);
})

// protons and neutrons slows down (like wind resistance)
neutrons.forEach((neutron) => resistance(neutron, 0.95));
protons.forEach((proton) => resistance(proton, 0.95));

// Electrons have a max velocity
electrons.forEach((electron) => {maxVelocity(electron, 5)});

// Step the physics world
world.step(timeStep);
// Copy coordinates from Cannon.js to Three.js
protons.forEach(updateMeshState);
neutrons.forEach(updateMeshState);
electrons.forEach(updateMeshState);

renderer.render(scene, camera);
};

function updateMeshState(object){
object.mesh.position.copy(object.body.position);
object.mesh.quaternion.copy(object.body.quaternion);
}

function pullOrigin(object){
object.body.force.set(
-object.body.position.x,
-object.body.position.y,
-object.body.position.z
);
}

function maxVelocity(object, vel){
if(object.body.velocity.length() > vel)
object.body.force.set(0, 0, 0);
}

function resistance(object, val) {
if(object.body.velocity.length() > 0)
object.body.velocity.scale(val, object.body.velocity);
}
render();``````
``````<script src="https://cdnjs.cloudflare.com/ajax/libs/cannon.js/0.6.2/cannon.min.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/three.js/r75/three.min.js"></script>``````
``````function Atom(nProtons, nNeutrons, nElectrons, pos = new CANNON.Vec3(0, 0, 0)){

//variable to move the atom, which att the particles will pull towards
let position = pos;

// create our Atom
let protons = Array(nProtons).fill(0).map( () => Proton() );
let neutrons = Array(nNeutrons).fill(0).map( () => Neutron() );
let electrons = Array(nElectrons).fill(0).map( () => Electron() );

// Public Functions
//=================
// add to a three.js and CANNON scene/world
protons.forEach((proton) => {
});
neutrons.forEach((neutron) => {
});
electrons.forEach((electron) => {
});
}

function simulate() {

protons.forEach(pullParticle);
neutrons.forEach(pullParticle);

//pull electrons if they are further than 5 away
electrons.forEach((electron) => { pullParticle(electron, 5) });
//push electrons if they are closer than 6 away
electrons.forEach((electron) => { pushParticle(electron, 6) });

// give the particles some friction/wind resistance
//electrons.forEach((electron) => resistance(electron, 0.95));
neutrons.forEach((neutron) => resistance(neutron, 0.95));
protons.forEach((proton) => resistance(proton, 0.95));

}

function electronStartingVelocity(vel) {
electrons.forEach((electron) => {
let centerDir = electron.body.position.vsub(position);
centerDir.normalize();
let impulse = centerDir.cross(new CANNON.Vec3(0, 0, 1));
impulse.scale(vel, impulse);
electron.body.applyLocalImpulse(impulse, new CANNON.Vec3(0, 0, 0));
});
}

// Should be called after CANNON has simulated a frame and before THREE renders.
function updateAtomMeshState(){
protons.forEach(updateMeshState);
neutrons.forEach(updateMeshState);
electrons.forEach(updateMeshState);
}

// Private Functions
// =================

// pull a particale towards the atom position (if it is more than distance away)
function pullParticle(particle, distance = 0){

// if particle is close enough, dont pull more
if(particle.body.position.distanceTo(position) < distance)
return false;

//create vector pointing from particle to atom position
let pullForce = position.vsub(particle.body.position);

// same as: particle.body.force = particle.body.force.vadd(pullForce)
pullForce,              // to pullForce
particle.body.force);   // and put it in particle force
}

// Push a particle from the atom position (if it is less than distance away)
function pushParticle(particle, distance = 0){

// if particle is far enough, dont push more
if(particle.body.position.distanceTo(position) > distance)
return false;

//create vector pointing from particle to atom position
let pushForce = particle.body.position.vsub(position);

pushForce,              // to pushForce
particle.body.force);   // and put it in particle force
}

// give a partile some friction
function resistance(particle, val) {
if(particle.body.velocity.length() > 0)
particle.body.velocity.scale(val, particle.body.velocity);
}

// Call this on a particle if you want to limit its velocity
function limitVelocity(particle, vel){
if(particle.body.velocity.length() > vel)
particle.body.force.set(0, 0, 0);
}

// copy ratation and position from CANNON to THREE
function updateMeshState(particle){
particle.mesh.position.copy(particle.body.position);
particle.mesh.quaternion.copy(particle.body.quaternion);
}

// public API
return {
"simulate":                 simulate,
"electrons":                electrons,
"neutrons":                 neutrons,
"protons":                  protons,
"position":                 position,
"updateAtomMeshState":      updateAtomMeshState,
"electronStartingVelocity": electronStartingVelocity,

}
}

function Proton(){

return {
// Cannon
body: new CANNON.Body({
mass: 1, // kg
position: randomPosition(0, 6), // random pos from radius 0-6
}),
// THREE
mesh: new THREE.Mesh(
new THREE.SphereGeometry( radius, 32, 32 ),
new THREE.MeshPhongMaterial( { color: 0xdd5555, specular: 0x999999, shininess: 13} )
)
}
}

function Neutron(){

return {
// Cannon
body: new CANNON.Body({
mass: 1, // kg
position: randomPosition(0, 6), // random pos from radius 0-6
}),
// THREE
mesh: new THREE.Mesh(
new THREE.SphereGeometry( radius, 32, 32 ),
new THREE.MeshPhongMaterial( { color: 0x55dddd, specular: 0x999999, shininess: 13} )
)
}
}

function Electron(){

return {
// Cannon
body: new CANNON.Body({
mass: 0.5, // kg
position: randomPosition(3, 7), // random pos from radius 3-8
}),
// THREE
mesh: new THREE.Mesh(
new THREE.SphereGeometry( radius, 32, 32 ),
new THREE.MeshPhongMaterial( { color: 0xdddd55, specular: 0x999999, shininess: 13} )
)
}
}

// get random direction
let x = (2 * Math.random() - 1 ),
y = (2 * Math.random() - 1 ),
z = (2 * Math.random() - 1 )

// create vector
let randVec = new CANNON.Vec3(x, y, z);

// normalize
randVec.normalize();
// scale it to the right radius
return randVec;
}
``````
``````let scene = new THREE.Scene();
let world = new CANNON.World();
world.solver.iterations = 5;

let camera = new THREE.PerspectiveCamera( 75, window.innerWidth/window.innerHeight, 0.1, 1000 );

let renderer = new THREE.WebGLRenderer();
renderer.setSize( window.innerWidth, window.innerHeight );
document.body.appendChild( renderer.domElement );

// create a Atom with 3 protons and neutrons, and 5 electrons
// all circulating position (-4, 0, 0)
let atom = Atom(3, 3, 5, new CANNON.Vec3(-4, 0, 0));

// move atom (will not be instant)
//atom.position.x = -2;

// add to THREE scene and CANNON world

let light = new THREE.AmbientLight( 0x202020 ); // soft white light

let directionalLight = new THREE.DirectionalLight( 0xffffff, 0.5 );
directionalLight.position.set( -1, 1, 1 );

camera.position.z = 18;

const timeStep = 1/60;

// give the atoms electrons some starting velocity
atom.electronStartingVelocity(2);

function render () {
requestAnimationFrame( render );

// calculate all the particles positions
atom.simulate();

// Step the physics world
world.step(timeStep);

//update the THREE mesh
atom.updateAtomMeshState();

renderer.render(scene, camera);
};

render();
``````

## When drawing spheres and lines at the same position, they are drawn at different places

Tag : development , By : pcoramc
Date : March 29 2020, 07:55 AM
it fixes the issue My bad, I was applying the rotation to the sphere geometries after positioning them, so the spheres were being rotated around the origin.