Develop Reference

ARCore: Get the 3D coordinates of all detected points

I’m programming an app for point cloud detection with ARCore in Java.
I want to get the 3D coordinates of all points, which are rendered in the frames. Currently I get only a very few of these points, if I use the following code.
pointCloud = frame.acquirePointCloud();
if (list1 != null) {
String x = String.valueOf(df.format(pointCloud.getPoints().get(0))).replace(",", ".");
String y = String.valueOf(df.format(pointCloud.getPoints().get(1))).replace(",", ".");
String z = String.valueOf(df.format(pointCloud.getPoints().get(2))).replace(",", ".");
String c = String.valueOf(df.format(pointCloud.getPoints().get(3))).replace(",", ".");
list1.add(x + ", " + y + ", " + z + ", " + c + "\n");
}
I only found one other implementation. I tried this one, but I got a lot of confusing points, which drifted away.
pointCloud = frame.acquirePointCloud();
if (list6 != null) {
FloatBuffer fb = pointCloud.getPoints();
while (fb.hasRemaining()) {
float x = Float.parseFloat(df.format(fb.get()).replace(",", "."));
float y = Float.parseFloat(df.format(fb.get()).replace(",", "."));
float z = Float.parseFloat(df.format(fb.get()).replace(",", "."));
float c = Float.parseFloat(df.format(fb.get()).replace(",", "."));
list6.add(x + ", " + y + ", " + z + ", " + c + "\n");
}
}
I´m not sure that it is a problem in the code.
Does sombody have a better idea to get all points or can tell me what I’m doing wrong?
I would be glad about some help. Thanks.

I have used this code for acquiring Point Cloud data. You can check the length of Point Cloud Ids array to know the exact number of Point Clouds.
Using the below code you can map the Point Data to exact ID and be sure if all the data is available.
PointCloud pointCloud = frame.acquirePointCloud();
IntBuffer pointCloudIds = pointCloud.getIds();
int[] pointCloudIdsArray = new int[pointCloudIds.limit()];
pointCloudIds.get(pointCloudIdsArray);
Log.i(TAG, "onDrawFrame: Point Cloud Id Array Length " +
pointCloudIdsArray.length);
FloatBuffer pointCloudData = pointCloud.getPoints();
float[] pointCloudArray = new float[pointCloudData.limit()];
pointCloudData.get(pointCloudArray);
Log.i(TAG, "onDrawFrame: Point Cloud Data Array Length " + pointCloudArray.length);
long PointCloudTimeStamp = pointCloud.getTimestamp();
if (pointCloudIdsArray.length > 0) {
for (int i = 0; i < pointCloudIdsArray.length; i++) {
Log.i("TAG",Long.toString(PointCloudTimeStamp) + ";" +
Integer.toString(pointCloudIdsArray[i]) + ";" +
Float.toString(pointCloudArray[i * 4]) + ";" +
Float.toString(pointCloudArray[i * 4 + 1]) + ";" +
Float.toString(pointCloudArray[i * 4 + 2]) + ";" +
Float.toString(pointCloudArray[i * 4 + 3]) + "\n");
}
}

Euler Project - Work out the first ten digits of the sum of the following one-hundred 50-digit numbers

I know that it is a horrible question to ask at this forum since I do know the rules but at the moment I just do not know what the issue is here. So for anyone that has some spare time I would be very thankful if it could be answered. I tried to carry out the Euler Project exercise number 13: Work out the first ten digits of the sum of the following one-hundred 50-digit numbers.
I know the logic that I have used behind it is not the best and later I managed to solve the problem using another method, but it still bothers me until today why does the following code not work:
import java.util.ArrayList;
public class LargeSum {
public static ArrayList<String> addAll(ArrayList<ArrayList<Integer>> listOfResults) {
ArrayList<String> result = new ArrayList<String>();
int singlesum = 0;
int remainder = 0;
for (int i = 49; i >= 0; i--) {
System.out.println(remainder + "to rem");
singlesum += remainder;
for (ArrayList<Integer> list : listOfResults) {
System.out.println(list.get(i));
singlesum += list.get(i);
}
String lastChar = String.valueOf(singlesum);
singlesum = 0;
result.add(String.valueOf(lastChar.charAt(lastChar.length() - 1)));
remainder = 0;
if (lastChar.length() > 1) {
remainder = Integer.parseInt(lastChar.substring(0, lastChar.length() - 1));
}
}
if (remainder > 0)
result.add(String.valueOf(remainder));
return result;
}
public static ArrayList<ArrayList<Integer>> createLists() {
ArrayList<ArrayList<Integer>> results = new ArrayList<ArrayList<Integer>>();
String c =
"37107287533902102798797998220837590246510135740250"
+ "46376937677490009712648124896970078050417018260538"
+ "74324986199524741059474233309513058123726617309629"
+ "91942213363574161572522430563301811072406154908250"
+ "23067588207539346171171980310421047513778063246676"
+ "89261670696623633820136378418383684178734361726757"
+ "28112879812849979408065481931592621691275889832738"
+ "44274228917432520321923589422876796487670272189318"
+ "47451445736001306439091167216856844588711603153276"
+ "70386486105843025439939619828917593665686757934951"
+ "62176457141856560629502157223196586755079324193331"
+ "64906352462741904929101432445813822663347944758178"
+ "92575867718337217661963751590579239728245598838407"
+ "58203565325359399008402633568948830189458628227828"
+ "80181199384826282014278194139940567587151170094390"
+ "35398664372827112653829987240784473053190104293586"
+ "86515506006295864861532075273371959191420517255829"
+ "71693888707715466499115593487603532921714970056938"
+ "54370070576826684624621495650076471787294438377604"
+ "53282654108756828443191190634694037855217779295145"
+ "36123272525000296071075082563815656710885258350721"
+ "45876576172410976447339110607218265236877223636045"
+ "17423706905851860660448207621209813287860733969412"
+ "81142660418086830619328460811191061556940512689692"
+ "51934325451728388641918047049293215058642563049483"
+ "62467221648435076201727918039944693004732956340691"
+ "15732444386908125794514089057706229429197107928209"
+ "55037687525678773091862540744969844508330393682126"
+ "18336384825330154686196124348767681297534375946515"
+ "80386287592878490201521685554828717201219257766954"
+ "78182833757993103614740356856449095527097864797581"
+ "16726320100436897842553539920931837441497806860984"
+ "48403098129077791799088218795327364475675590848030"
+ "87086987551392711854517078544161852424320693150332"
+ "59959406895756536782107074926966537676326235447210"
+ "69793950679652694742597709739166693763042633987085"
+ "41052684708299085211399427365734116182760315001271"
+ "65378607361501080857009149939512557028198746004375"
+ "35829035317434717326932123578154982629742552737307"
+ "94953759765105305946966067683156574377167401875275"
+ "88902802571733229619176668713819931811048770190271"
+ "25267680276078003013678680992525463401061632866526"
+ "36270218540497705585629946580636237993140746255962"
+ "24074486908231174977792365466257246923322810917141"
+ "91430288197103288597806669760892938638285025333403"
+ "34413065578016127815921815005561868836468420090470"
+ "23053081172816430487623791969842487255036638784583"
+ "11487696932154902810424020138335124462181441773470"
+ "63783299490636259666498587618221225225512486764533"
+ "67720186971698544312419572409913959008952310058822"
+ "95548255300263520781532296796249481641953868218774"
+ "76085327132285723110424803456124867697064507995236"
+ "37774242535411291684276865538926205024910326572967"
+ "23701913275725675285653248258265463092207058596522"
+ "29798860272258331913126375147341994889534765745501"
+ "18495701454879288984856827726077713721403798879715"
+ "38298203783031473527721580348144513491373226651381"
+ "34829543829199918180278916522431027392251122869539"
+ "40957953066405232632538044100059654939159879593635"
+ "29746152185502371307642255121183693803580388584903"
+ "41698116222072977186158236678424689157993532961922"
+ "62467957194401269043877107275048102390895523597457"
+ "23189706772547915061505504953922979530901129967519"
+ "86188088225875314529584099251203829009407770775672"
+ "11306739708304724483816533873502340845647058077308"
+ "82959174767140363198008187129011875491310547126581"
+ "97623331044818386269515456334926366572897563400500"
+ "42846280183517070527831839425882145521227251250327"
+ "55121603546981200581762165212827652751691296897789"
+ "32238195734329339946437501907836945765883352399886"
+ "75506164965184775180738168837861091527357929701337"
+ "62177842752192623401942399639168044983993173312731"
+ "32924185707147349566916674687634660915035914677504"
+ "99518671430235219628894890102423325116913619626622"
+ "73267460800591547471830798392868535206946944540724"
+ "76841822524674417161514036427982273348055556214818"
+ "97142617910342598647204516893989422179826088076852"
+ "87783646182799346313767754307809363333018982642090"
+ "10848802521674670883215120185883543223812876952786"
+ "71329612474782464538636993009049310363619763878039"
+ "62184073572399794223406235393808339651327408011116"
+ "66627891981488087797941876876144230030984490851411"
+ "60661826293682836764744779239180335110989069790714"
+ "85786944089552990653640447425576083659976645795096"
+ "66024396409905389607120198219976047599490197230297"
+ "64913982680032973156037120041377903785566085089252"
+ "16730939319872750275468906903707539413042652315011"
+ "94809377245048795150954100921645863754710598436791"
+ "78639167021187492431995700641917969777599028300699"
+ "15368713711936614952811305876380278410754449733078"
+ "40789923115535562561142322423255033685442488917353"
+ "44889911501440648020369068063960672322193204149535"
+ "41503128880339536053299340368006977710650566631954"
+ "81234880673210146739058568557934581403627822703280"
+ "82616570773948327592232845941706525094512325230608"
+ "22918802058777319719839450180888072429661980811197"
+ "77158542502016545090413245809786882778948721859617"
+ "72107838435069186155435662884062257473692284509516"
+ "20849603980134001723930671666823555245252804609722";
for (int i = 0; i < 4950; i += 50) {
ArrayList<Integer> strings = new ArrayList<Integer>();
for (int j = i; j <= i + 49; j++) {
strings.add(Integer.parseInt(String.valueOf(c.charAt(j))));
}
results.add(strings);
}
return results;
}
public static void main(String[] args) {
ArrayList<ArrayList<Integer>> results = createLists();
System.out.println(addAll(results));
}
}
The array should give me the number from the back one by one each digit of the number yet I do not get the answer to the question. I investigated this many times for smaller numbers (where it worked) and for only two numbers (and it worked) yet I cannot get the answer to the question (I always get another number as result not the designated Result: 5537376230).
Thanks to everybody that looks at the code.
Best regards,
Rob

I believe the main source of the issue lies in the fact that you hardcoded a lot of numerical values and thus can not really verify correctness in the middle steps. Especially bad idea is using single String instead of the array of String[] for your source data.
Anyway, if you re-check the task you may find that the last numbers are:
...
72107838435069186155435662884062257473692284509516
20849603980134001723930671666823555245252804609722
53503534226472524250874054075591789781264330331690
while in your code you have:
+ "72107838435069186155435662884062257473692284509516"
+ "20849603980134001723930671666823555245252804609722";
So you just missed the last number and that spoils the result.
Sidenotes:
you don't really handle the top digits (your "top" digit is "55") properly which is a result of a lot of hardcoding but you probably already know that.
In java there is a BigInteger class that can solves this task easily. It is OK to write your own code for learning but for the real world task you should use a standard library unless you have a good reason not to use it.

In the case where you have a remainder left over, you add it to result as a string. But the digits in your results are reversed, so you also need to reverse the digits of the remainder.
It also looks like you've got an off-by-one error in the construction of your numbers. i < 4950 should be i < 5000 I think, since the 100th number starts at index 99 * 50 = 4950.

I can't get the right answer to Project Euler Q8 with Java

There are 2 answers. The first answer is for 4 consecutive numbers and the answer is provided: 5832. The 2nd answer is for 13 consecutive numbers and it's the answer they want me to input. This answer is: 23514624000.
My answer for the 1st questions is: 29760696 which is impossible and way off
public class test {
public static void main(String[] args)
{
String big = "73167176531330624919225119674426574742355349194934"
+ "96983520312774506326239578318016984801869478851843"
+ "85861560789112949495459501737958331952853208805511"
+ "12540698747158523863050715693290963295227443043557"
+ "66896648950445244523161731856403098711121722383113"
+ "62229893423380308135336276614282806444486645238749"
+ "30358907296290491560440772390713810515859307960866"
+ "70172427121883998797908792274921901699720888093776"
+ "65727333001053367881220235421809751254540594752243"
+ "52584907711670556013604839586446706324415722155397"
+ "53697817977846174064955149290862569321978468622482"
+ "83972241375657056057490261407972968652414535100474"
+ "82166370484403199890008895243450658541227588666881"
+ "16427171479924442928230863465674813919123162824586"
+ "17866458359124566529476545682848912883142607690042"
+ "24219022671055626321111109370544217506941658960408"
+ "07198403850962455444362981230987879927244284909188"
+ "84580156166097919133875499200524063689912560717606"
+ "05886116467109405077541002256983155200055935729725"
+ "71636269561882670428252483600823257530420752963450"
;
//System.out.println(big.length());
int product=1;
int newProduct=0;
for(int i=0;i<big.length()-1-4;i++)
{
product=1;
for(int j=i+1;j<i+5;j++)
{
product=(big.charAt(i)-48)*(big.charAt(j)-48)*product;
}
if(product>newProduct)
{
newProduct=product;
}
}
System.out.println(newProduct);
}
My answer for the 2nd question is: 2135048192 and is a lot closer. Why is this the case? My code is as follows. thanks
public class test {
public static void main(String[] args)
{
String big = "73167176531330624919225119674426574742355349194934"
+ "96983520312774506326239578318016984801869478851843"
+ "85861560789112949495459501737958331952853208805511"
+ "12540698747158523863050715693290963295227443043557"
+ "66896648950445244523161731856403098711121722383113"
+ "62229893423380308135336276614282806444486645238749"
+ "30358907296290491560440772390713810515859307960866"
+ "70172427121883998797908792274921901699720888093776"
+ "65727333001053367881220235421809751254540594752243"
+ "52584907711670556013604839586446706324415722155397"
+ "53697817977846174064955149290862569321978468622482"
+ "83972241375657056057490261407972968652414535100474"
+ "82166370484403199890008895243450658541227588666881"
+ "16427171479924442928230863465674813919123162824586"
+ "17866458359124566529476545682848912883142607690042"
+ "24219022671055626321111109370544217506941658960408"
+ "07198403850962455444362981230987879927244284909188"
+ "84580156166097919133875499200524063689912560717606"
+ "05886116467109405077541002256983155200055935729725"
+ "71636269561882670428252483600823257530420752963450"
;
//System.out.println(big.length());
int product=1;
int newProduct=0;
for(int i=0;i<big.length()-1-13;i++)
{
product=1;
for(int j=i+1;j<i+14;j++)
{
product=(big.charAt(i)-48)*(big.charAt(j)-48)*product;
}
if(product>newProduct)
{
newProduct=product;
}
}
System.out.println(newProduct);
}

You are experiencing integer overflow (use a long). Character.digit(char,int) (where the second argument is the radix) can get you the int value of a char). Also, you can use Math.max(long, long) to get the maximum of two long(s). Putting that together, it might look something like
long max = 0;
for (int i = 0; i < big.length() - 13; i++) {
String str = big.substring(i, i + 13);
long product = 1;
for (char ch : str.toCharArray()) {
product *= Character.digit(ch, 10);
}
max = Math.max(max, product);
}
System.out.println(max);
And I get (the expected)
23514624000

Deleting last new line string

So I've tried pretty much everything to get rid of the last newline character in my code. Its supposed to print a new line after every recursive call except for the last one. Any ideas?
public static boolean solve(double target, ArrayList<Double> numbers)
{
String print = "";
String newPrint = "";
double compare = 0;
boolean done = false;
for (double num : numbers)
{
if (!done)
{
ArrayList<Double> remaining = new ArrayList<Double>(numbers);
remaining.remove(num);
if (target == num)
{
done = true;
}
else
{
done = solve(target + num, remaining);
if (done)
{
print += ((int) target + (int) num) + " " + "-" + " " + (int) num + " "
+ "="
+ " "
+ ((int) target + "\n");
}
else
{
done = solve(target - num, remaining);
if (done)
{
print += ((int) target - (int) num) + " " + "+" + " " + (int) num + " "
+ "=" + " "
+ ((int) target + "\n");
}
else
{
done = solve(target * num, remaining);
if (done)
{
print += ((int) target * (int) num) + " " + "/" + " " + (int) num
+ " " + "=" + " "
+ ((int) target + "\n");
}
else
{
done = solve(target / num, remaining);
if (done)
{
print += ((int) target / (int) num) + " " + "*" + " "
+ (int) num
+ " " + "="
+ " " + ((int) target + "\n");
}
}
}
}
}
}
}
System.out.print(print);
return done;
}
}

For instance:
void recursiveF(...) {
if ... {
recursiveF(...);
println();
}
...
}

The result is a string but you don't want the last character, so remove it:
print = print.substring(0, print.length()-1);

Use trim() method. It will remove white spaces, newline etc from beginning and end of string.
System.out.print(print.trim());

Short Print the new line character before.
The first thing the recursive function should do is print the new line character.
This way you shift the odd case from the last function call, to the first call, which should not prepend a new line character.
You could add a parameter String prepend = "" to the signature of the recursive method, it's empty on the first call, all further calls have it set to String prepend = "\n".
Then you can just print prepend without bothering with its content.

Java AVL Tree Problems

I'm trying to build an AVL tree in Java, but I'm having trouble with updating heights after the rotations. Here is the code I'm having trouble with.
public void checkHeights(Node<T> u) {
if (u == nil) return;
checkHeights(u.left);
checkHeights(u.right);
System.out.println(u.h);
if (height(u) != 1 + Math.max(height(u.left), height(u.right)))
throw new RuntimeException("Check heights shows incorrect heights");
int dif = height(u.left) - height(u.right);
if (dif < -1 || dif > 1)
throw new RuntimeException("Check heights found height difference of " + dif);
}
/**
* Fix up
* #param u
*/
public void fixup(Node<T> u) {
while (u != nil) {
int dif = height(u.left) - height(u.right);
if(debug)System.out.println("Node dif at " + u.x + " is: " + dif);
if (dif > 1) {
if(debug)System.out.println("u.left is larger");
if(height(u.left.left) - height(u.left.right) < 0) {
if(debug)System.out.println("u.left dif is: " + (height(u.left.left) - height(u.left.right)));
rotateLeft(u.left);
}
rotateRight(u);
} else if (dif < -1) {
if(debug)System.out.println("u.right is larger");
if(height(u.right.left) - height(u.right.right) > 0) {
if(debug)System.out.println("u.right dif is: " + (height(u.right.left) - height(u.right.right)));
rotateRight(u.right);
}
rotateLeft(u);
}
if(debug) System.out.println("Height of " + u.x + " is " + height(u));
u = u.parent;
}
}
public void rotateLeft(Node<T> u) {
super.rotateLeft(u);
u.h = Math.max(height(u.left), height(u.right)) + 1;
u.parent.h = Math.max(height(u.parent.left), height(u.parent.right)) + 1;
if(debug)System.out.println("After left rotation, " + u.x + " has height " + u.h + " and " + u.parent.x + " has height " + u.parent.h);
}
public void rotateRight(Node<T> u) {
super.rotateRight(u);
u.h = Math.max(height(u.left), height(u.right)) + 1;
u.parent.h = Math.max(height(u.parent.left), height(u.parent.right)) + 1;
if(debug)System.out.println("After right rotation, " + u.x + " has height " + u.h + " and " + u.parent.x + " has height " + u.parent.h);
}
I've done a bunch of unit tests, and I keep getting checkHeights throwing exceptions. I'm almost positive that what's going on is the when a rotation occurs at a depth greater than 2, the heights aren't updated recursively up the tree. For example, if I add values from 0 to 10 in, the first left rotation occurs no problem and the values get their right heights, but when I try to rotate lower down, the parent nodes aren't accurately update to their new heights, causing the exceptions to be thrown.
Any help would be greatly appreciated