How to change the position of each PVector objects in an ArrayList that is made by an ArrayList? - processing

Question

I am currently working on an ArrayList of an ArrayList that I want the outer ArrayList to have different locations.
So I tried to use thetranslate(); to distinguish the position of the outer ArrayList but it doesn't work. On screen it is still showing all the ArrayList at one place.
I have also tried to multiply the points location with point(v3.x * gap, v3.y * gap, v3.z * gap); but it doesn't work neither.
Does anyone knows is ther a way on how can I alter the location of outer ArrayList?
Here are the codes I am working on:
//import
import peasy.*;
//import variables
PeasyCam acam;
//position variable for pointSphere
float x;
float y;
float z;
float gap = 500;
//arraylist of arraylist
ArrayList<ArrayList <PVector>> sphereList = new ArrayList<ArrayList<PVector>>();
//empty arraylist
ArrayList<PVector> sphere1 = new ArrayList<PVector>();
void setup() {
size(1920, 1080, P3D);
//camera setting
acam = new PeasyCam(this, 500, 500, 500, 2000);
acam.rotateX(0);
acam.rotateY(0);
acam.rotateZ(0);
pointSphere(270, 27, 27);
}
void draw() {
background(0);
for (int i = 0; i < sphere1.size(); i++) {
PVector v1;
v1 = sphere1.get(i);
stroke(255);
strokeWeight(random(2, 10));
point(v1.x, v1.y, v1.z);
for (int j = 0; j < sphereList.size(); j++) {
PVector v3;
v3=sphereList.get(i).get(j);
pushMatrix();
gap = gap + 500;
translate(1000 + gap, 1000 + gap, 1000 + gap);
point(v3.x, v3.y, v3.z);
popMatrix();
}
}
}
void pointSphere (float r, float uAmount, float wAmount) {
for (float u= 0; u < 180; u += 180/uAmount) {
for (float w = 0; w < 360; w += 360/wAmount) {
//define PVector
PVector vS1 = new PVector(r*sin(radians(u))*cos(radians(w)), r*sin(radians(u))*sin(radians(w)), r*cos(radians(u)));
//storing the location of Pvector into sphere1
sphere1.add(vS1);
sphereList.add(sphere1);
}
}
}

Answer 1

You have most of the "ingredients" in place (sphere points, a scene to render into, translate to offset each sphere, etc.), however there are two sections that are confusing:
1.ArrayList<ArrayList <PVector>> sphereList = new ArrayList<ArrayList<PVector>>(); this would store a list of lists of points. Do you need to render multiple spheres each with a different set of points (e.g. different float r, float uAmount, float wAmount values ?) If so, this makes sense. However if you simply want to render the same sphere in different locations, you can get away with 1 list of points (i.e. just sphere1) and render it in multiple locations.
The nested for loops in draw(): the first loop accesses and draws the sphere points. The second loop iterates for every sphere point (which is a lot). This second loop would iterate through each point and translate.
If simply rendering the same sphere 3 times in 3 locations, you can translate the group of points (i.e. before the for loop rendering each point).
Here's one way of writing it:
I recommend tweaking the pointSphere() points function so it returns the points (instead of using the hardcoded list to add points to). The advantage is you can calculate sphere points with various settings that can be stored into independent lists of points (as opposed to the single hardcoded list). (Additionally, you could easily reuse this function in other sketches as it requires copything the function indepdent of the hardcoded list of points)
e.g.
ArrayList<PVector> pointSpherePoints(float r, float uAmount, float wAmount) {
ArrayList<PVector> points = new ArrayList<PVector>();
for (float u= 0; u < 180; u += 180/uAmount) {
for (float w = 0; w < 360; w += 360/wAmount) {
//define PVector
PVector vS1 = new PVector(r*sin(radians(u))*cos(radians(w)), r*sin(radians(u))*sin(radians(w)), r*cos(radians(u)));
//storing the location of Pvector
points.add(vS1);
}
}
return points;
}
you can write a function that renders a list of points which can be reused.
void drawSpherePoints(ArrayList<PVector> points){
for (int i = 0 ; i < points.size(); i++) {
PVector v = points.get(i);
stroke(255);
strokeWeight(random(2, 10));
point(v.x, v.y, v.z);
}
}
Putting the two together makes it simple to render the sphere in different places:
//import
import peasy.*;
//import variables
PeasyCam acam;
ArrayList<PVector> sphere1 = pointSpherePoints(270, 27, 27);
void setup() {
size(1920, 1080, P3D);
//camera setting
acam = new PeasyCam(this, 500, 500, 500, 2000);
acam.rotateX(0);
acam.rotateY(0);
acam.rotateZ(0);
}
void draw() {
background(0);
translate(width * 0.5, height * 0.5);
float gap = -1000;
for(int i = 0 ; i < 3; i++){
gap = gap + 500;
translate(1000 + gap, 1000 + gap, 1000 + gap);
drawSpherePoints(sphere1);
}
}
void drawSpherePoints(ArrayList<PVector> points){
for (int i = 0 ; i < points.size(); i++) {
PVector v = points.get(i);
stroke(255);
strokeWeight(random(2, 10));
point(v.x, v.y, v.z);
}
}
ArrayList<PVector> pointSpherePoints(float r, float uAmount, float wAmount) {
ArrayList<PVector> points = new ArrayList<PVector>();
for (float u= 0; u < 180; u += 180/uAmount) {
for (float w = 0; w < 360; w += 360/wAmount) {
//define PVector
PVector vS1 = new PVector(r*sin(radians(u))*cos(radians(w)), r*sin(radians(u))*sin(radians(w)), r*cos(radians(u)));
//storing the location of Pvector
points.add(vS1);
}
}
return points;
}
The encapsulation makes it easier to draw spheres with independent parameters (radius, detail level):
//import
import peasy.*;
//import variables
PeasyCam acam;
int numSpheres = 3;
ArrayList<ArrayList<PVector>> spheres = new ArrayList<ArrayList<PVector>>();
void setup() {
size(1920, 1080, P3D);
//camera setting
acam = new PeasyCam(this, 500, 500, 500, 2000);
for(int i = 0 ; i < numSpheres ; i++){
int detailLevel = i + 1;
spheres.add(pointSpherePoints(30 * (detailLevel * 2), 9 * detailLevel, 9 * detailLevel));
}
}
void draw() {
background(0);
translate(width * 0.5, height * 0.5);
for(int i = 0 ; i < numSpheres ; i++){
ArrayList<PVector> sphere = spheres.get(i);
translate(100 * i, 0, 0);
drawSpherePoints(sphere);
}
}
void drawSpherePoints(ArrayList<PVector> points){
for (int i = 0 ; i < points.size(); i++) {
PVector v = points.get(i);
stroke(255);
strokeWeight(random(2, 10));
point(v.x, v.y, v.z);
}
}
ArrayList<PVector> pointSpherePoints(float r, float uAmount, float wAmount) {
ArrayList<PVector> points = new ArrayList<PVector>();
for (float u= 0; u < 180; u += 180/uAmount) {
for (float w = 0; w < 360; w += 360/wAmount) {
//define PVector
PVector vS1 = new PVector(r*sin(radians(u))*cos(radians(w)), r*sin(radians(u))*sin(radians(w)), r*cos(radians(u)));
//storing the location of Pvector
points.add(vS1);
}
}
return points;
}
or even a sphere of spheres:
//import
import peasy.*;
//import variables
PeasyCam acam;
ArrayList<PVector> sphere1 = pointSpherePoints(270, 27, 27);
void setup() {
size(1920, 1080, P3D);
//camera setting
acam = new PeasyCam(this, 500, 500, 500, 2000);
}
void draw() {
background(0);
translate(width * 0.5, height * 0.5);
for(int i = 0 ; i < sphere1.size(); i += 10){
// scale vector point
PVector v = PVector.mult(sphere1.get(i), 10);
pushMatrix();
translate(v.x, v.y, v.z);
drawSpherePoints(sphere1);
popMatrix();
}
}
void drawSpherePoints(ArrayList<PVector> points){
for (int i = 0 ; i < points.size(); i++) {
PVector v = points.get(i);
stroke(255);
strokeWeight(random(2, 10));
point(v.x, v.y, v.z);
}
}
ArrayList<PVector> pointSpherePoints(float r, float uAmount, float wAmount) {
ArrayList<PVector> points = new ArrayList<PVector>();
for (float u= 0; u < 180; u += 180/uAmount) {
for (float w = 0; w < 360; w += 360/wAmount) {
//define PVector
PVector vS1 = new PVector(r*sin(radians(u))*cos(radians(w)), r*sin(radians(u))*sin(radians(w)), r*cos(radians(u)));
//storing the location of Pvector
points.add(vS1);
}
}
return points;
}