title: PApplet error on IntelliJ
body: <p>I am trying to use the Processing and OpenKinect library on IntelliJ to connect my Kinect to use it for hand detection, this code works on Processing 3 but for some reason when I put it up on IntelliJ, in proper format, I get this error: </p>
  
  <blockquote>
    <p>Usage: PApplet [options]  [sketch args] See the Javadoc
    for PApplet for an explanation.</p>
  </blockquote>
  
  <p>These are the two classes I am using.</p>
  
  <p><strong>Main.java</strong></p>
  
  <pre><code>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);
              }
          }
      }
  }
  </code></pre>
  
  <p><strong>KinectTracker.java</strong></p>
  
  <pre><code>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 &lt; kinect.width; x++) {
              for (int y = 0; y &lt; kinect.height; y++) {
  
                  int offset =  x + y*kinect.width;
                  // Grabbing the raw depth
                  int rawDepth = depth[offset];
  
                  // Testing against threshold
                  if (rawDepth &lt; 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 &lt; kinect.width; x++) {
              for (int y = 0; y &lt; kinect.height; y++) {
  
                  int offset = x + y * kinect.width;
                  // Raw depth
                  int rawDepth = depth[offset];
                  int pix = x + y * display.width;
                  if (rawDepth &lt; 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;
      }
  }
  </code></pre>