PApplet Fehler auf IntelliJ

Question

Ich versuche, die Verarbeitung und OpenKinect-Bibliothek auf IntelliJ verwenden, um meine Kinect zu verbinden, um es für die Handerkennung zu verwenden, dieser Code funktioniert auf Verarbeitung 3, aber aus irgendeinem Grund, wenn ich es auf IntelliJ, richtig Format, erhalte ich diesen Fehler:

Usage: PApplet [options] [sketch args] See the Javadoc for PApplet for an explanation.

Dies sind die zwei Klassen, die ich verwende.

Main.java

package lol.uk; 

import processing.core.*; 
//import org.openkinect.freenect.*; 
import org.openkinect.processing.*; 
import processing.core.PImage; 
import processing.core.PVector; 
//import processing.core.PImage; 

public class Main extends PApplet { 

    KinectTracker tracker; 
    Kinect kinect; 


    public void setup() { 
     size(640, 520); 
     kinect = new Kinect(this); 
     tracker = new KinectTracker(); 
    } 

    public void draw() { 
     background(255); 

     // Run the tracking analysis 
     tracker.track(); 
     // Show the image 
     tracker.display(); 

     // Let's draw the raw location 
     PVector v1 = tracker.getPos(); 
     fill(50, 100, 250, 200); 
     noStroke(); 
     ellipse(v1.x, v1.y, 20, 20); 

     // Let's draw the "lerped" location 
     PVector v2 = tracker.getLerpedPos(); 
     fill(100, 250, 50, 200); 
     noStroke(); 
     ellipse(v2.x, v2.y, 20, 20); 

     // Display some info 
     int t = tracker.getThreshold(); 
     fill(0); 
     text("threshold: " + t + " " + "framerate: " + (frameRate) + " " + "UP increase threshold, DOWN decrease threshold", 10, 500); 
    } 

    public void keyPressed() { 
     int t = tracker.getThreshold(); 
     if (key == CODED) { 
      if (keyCode == UP) { 
       t += 5; 
       tracker.setThreshold(t); 
      } else if (keyCode == DOWN) { 
       t -= 5; 
       tracker.setThreshold(t); 
      } 
     } 
    } 
} 

KinectTracker.java

package lol.uk; 

import org.openkinect.processing.Kinect; 
import processing.core.*; 
import processing.core.PImage; 
import processing.core.PVector; 

public class KinectTracker extends PApplet { 
    // Depth threshold 
    int threshold = 500; 

    Kinect kinect; 

    // Raw location 
    PVector loc; 

    // Interpolated location 
    PVector lerpedLoc; 

    // Depth data 
    int[] depth; 

    // What we'll show the user 
    PImage display; 

    KinectTracker() { 
     // This is an awkard use of a global variable here 
     // But doing it this way for simplicity 
     kinect.initDepth(); 
     kinect.enableMirror(true); 
     // Make a blank image 
     display = createImage(kinect.width, kinect.height, RGB); 
     // Set up the vectors 
     loc = new PVector(0, 0); 
     lerpedLoc = new PVector(0, 0); 
    } 

    public void track() { 
     // Get the raw depth as array of integers 
     depth = kinect.getRawDepth(); 

     // Being overly cautious here 
     if (depth == null) return; 

     float sumX = 0; 
     float sumY = 0; 
     float count = 0; 

     for (int x = 0; x < kinect.width; x++) { 
      for (int y = 0; y < kinect.height; y++) { 

       int offset = x + y*kinect.width; 
       // Grabbing the raw depth 
       int rawDepth = depth[offset]; 

       // Testing against threshold 
       if (rawDepth < threshold) { 
        sumX += x; 
        sumY += y; 
        count++; 
       } 
      } 
     } 
     // As long as we found something 
     if (count != 0) { 
      loc = new PVector(sumX/count, sumY/count); 
     } 

     // Interpolating the location, doing it arbitrarily for now 
     lerpedLoc.x = PApplet.lerp(lerpedLoc.x, loc.x, 0.3f); 
     lerpedLoc.y = PApplet.lerp(lerpedLoc.y, loc.y, 0.3f); 
    } 

    PVector getLerpedPos() { 
     return lerpedLoc; 
    } 

    PVector getPos() { 
     return loc; 
    } 

    public void display() { 
     PImage img = kinect.getDepthImage(); 

     // Being overly cautious here 
     if (depth == null || img == null) return; 

     // Going to rewrite the depth image to show which pixels are in threshold 
     // A lot of this is redundant, but this is just for demonstration purposes 
     display.loadPixels(); 
     for (int x = 0; x < kinect.width; x++) { 
      for (int y = 0; y < kinect.height; y++) { 

       int offset = x + y * kinect.width; 
       // Raw depth 
       int rawDepth = depth[offset]; 
       int pix = x + y * display.width; 
       if (rawDepth < threshold) { 
        // A red color instead 
        display.pixels[pix] = color(150, 50, 50); 
       } else { 
        display.pixels[pix] = img.pixels[offset]; 
       } 
      } 
     } 
     display.updatePixels(); 

     // Draw the image 
     image(display, 0, 0); 
    } 

    int getThreshold() { 
     return threshold; 
    } 

    public void setThreshold(int t) { 
     threshold = t; 
    } 
} 

Answer 1

PApplet braucht ein paar Argumente zu starten. Hast du diese geliefert?

Siehe diese Seite für ein Beispiel: https://processing.org/tutorials/eclipse/

Answer 2

Warum Sie zwei Klassen haben, die PApplet verlängern?

99,99% der Zeit, sollten Sie nur eine Klasse, die PApplet erstreckt. Sie würden dann Instanzen dieser Klasse an andere Klassen weitergeben, um Verarbeitungsfunktionen aufzurufen.

Es sei denn, Sie haben einen sehr guten Grund, um PApplet zweimal zu verlängern, dann sollten Sie es wahrscheinlich nur einmal verlängern.

Warum haben Sie keine main() Methode?

Wenn Sie dies nicht über den Verarbeitungseditor ausführen, müssen Sie Ihre eigene main()-Methode schreiben, um Ihren Code zu starten. In Ihrer main()-Methode müssen Sie die PApplet.main("YourSketchClassNameHere")-Funktion aufrufen, um Verarbeitung zu informieren, Ihre Skizze zu starten.