DistanceRenderer.java

Go to the documentation of this file.

/*
 * Copyright (C) 2011 Google Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License"); you may not
 * use this file except in compliance with the License. You may obtain a copy of
 * the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 * License for the specific language governing permissions and limitations under
 * the License.
 */

package org.ros.android.view;

import android.content.Context;
import android.content.SharedPreferences;
import android.opengl.GLSurfaceView;
import android.opengl.GLU;
import android.preference.PreferenceManager;

import java.util.List;

import javax.microedition.khronos.egl.EGLConfig;
import javax.microedition.khronos.opengles.GL10;

class DistanceRenderer implements GLSurfaceView.Renderer {

  private static final float MIN_FOV_DISTANCE = 3f;
  private static final float MAX_FOV_DISTANCE = 8f;
  private static final float MIN_DISTANCE_ZOOM = -5.196152424f;
  private static final float MAX_DISTANCE_ZOOM = -13.856406465f;
  private static final float DISTANCE_VIEW_FIELD_OF_VIEW = 60f;
  private static final double DISTANCE_VIEW_ZOOM_MULTIPLIER = 1 / Math.tan(Math
      .toRadians(DISTANCE_VIEW_FIELD_OF_VIEW / 2));
  private static final String DISTANCE_VIEW_ZOOM_LOCK_KEY = "DISTANCE_VIEW_ZOOM_LOCK";
  private static final String DISTANCE_VIEW_ZOOM_MODE_KEY = "DISTANCE_VIEW_ZOOM_MODE";
  private static final String DISTANCE_VIEW_ZOOM_VALUE_KEY = "DISTANCE_VIEW_ZOOM_VALUE";
  private DistancePoints rangeLines;
  private float theta;
  private float zoom = MAX_DISTANCE_ZOOM;
  private ZoomMode zoomMode = ZoomMode.CLUTTER_ZOOM_MODE;
  private boolean zoomLocked;
  private SharedPreferences sharedPreferences;
  private SharedPreferences.Editor editor;

  @Override
  public void onSurfaceChanged(GL10 gl, int w, int h) {
    gl.glViewport(0, 0, w, h);
    gl.glMatrixMode(GL10.GL_PROJECTION);
    gl.glLoadIdentity();
    GLU.gluPerspective(gl, DISTANCE_VIEW_FIELD_OF_VIEW, (float) w / (float) h, 0.1f, 100.0f);
    gl.glMatrixMode(GL10.GL_MODELVIEW);
    gl.glLoadIdentity();
    gl.glHint(GL10.GL_POLYGON_SMOOTH_HINT, GL10.GL_NICEST);
  }

  @Override
  public void onSurfaceCreated(GL10 gl, EGLConfig arg1) {
    gl.glClearColor(0.0f, 0.0f, 0.0f, 0.5f);
    rangeLines = new DistancePoints();
  }

  @Override
  public void onDrawFrame(GL10 gl) {
    gl.glClear(GL10.GL_COLOR_BUFFER_BIT);
    gl.glLoadIdentity();
    // Move the camera up/down based on desired zoom level.
    gl.glTranslatef(0, 0, zoom);
    // Draw the distance triangles.
    rangeLines.drawRange(gl);
    // Draw the reference lines.
    rangeLines.drawReferenceMarker(gl);
    // Draw the robot.
    rangeLines.drawRobot(gl);
    gl.glRotatef(theta, 0, 0, -1f);
  }

  public void setRotation(float theta) {
    this.theta = theta;
  }

  public void setNormalizedZoom(float normalizedZoomValue) {
    if (zoomMode == ZoomMode.CUSTOM_ZOOM_MODE) {
      setZoom((1 - normalizedZoomValue) * (MAX_FOV_DISTANCE - MIN_FOV_DISTANCE) + MIN_FOV_DISTANCE);
    }
  }

  public void setZoomMode(ZoomMode mode) {
    zoomMode = mode;
  }

  public void lockZoom() {
    zoomLocked = true;
  }

  public void unlockZoom() {
    zoomLocked = false;
  }

  public void currentSpeed(double speed) {
    if (zoomMode == ZoomMode.VELOCITY_ZOOM_MODE) {
      setZoom((float) (Math.abs(speed) * ((MAX_FOV_DISTANCE - MIN_FOV_DISTANCE) + MIN_FOV_DISTANCE)));
    }
  }

  public void updateRange(List<Float> range, float maxRange, float minRange, float minTh,
      float thIncrement, float minDistToObject) {
    if (zoomMode == ZoomMode.CLUTTER_ZOOM_MODE) {
      // The closest object should be at the 80% of FOV mark.
      setZoom(minDistToObject * 1.25f);
    }
    // Update the distance ranges based on the incoming data.
    rangeLines.updateRange(range, maxRange, minRange, minTh, thIncrement);
  }

  public void loadPreferences(Context context) {
    sharedPreferences = PreferenceManager.getDefaultSharedPreferences(context);
    int tmpMode =
        sharedPreferences.getInt(DISTANCE_VIEW_ZOOM_MODE_KEY, ZoomMode.CUSTOM_ZOOM_MODE.ordinal());
    if (tmpMode == ZoomMode.CUSTOM_ZOOM_MODE.ordinal()) {
      zoomMode = ZoomMode.CUSTOM_ZOOM_MODE;
    } else if (tmpMode == ZoomMode.CLUTTER_ZOOM_MODE.ordinal()) {
      zoomMode = ZoomMode.CLUTTER_ZOOM_MODE;
    } else if (tmpMode == ZoomMode.VELOCITY_ZOOM_MODE.ordinal()) {
      zoomMode = ZoomMode.VELOCITY_ZOOM_MODE;
    }
    zoomLocked = sharedPreferences.getBoolean(DISTANCE_VIEW_ZOOM_LOCK_KEY, false);
    editor = sharedPreferences.edit();
  }

  public void savePreferences(Context context) {
    editor = sharedPreferences.edit();
    editor.putInt(DISTANCE_VIEW_ZOOM_MODE_KEY, zoomMode.ordinal());
    editor.putFloat(DISTANCE_VIEW_ZOOM_VALUE_KEY, zoom);
    editor.putBoolean(DISTANCE_VIEW_ZOOM_LOCK_KEY, zoomLocked);
    editor.apply();
  }

  private void setZoom(float distanceFromCenter) {
    if (!zoomLocked) {
      // Bounds checking.
      if (distanceFromCenter < MIN_FOV_DISTANCE) {
        zoom = MIN_DISTANCE_ZOOM;
      } else if (distanceFromCenter > MAX_FOV_DISTANCE) {
        zoom = MAX_DISTANCE_ZOOM;
      } else {
        zoom = (float) (-distanceFromCenter * DISTANCE_VIEW_ZOOM_MULTIPLIER);
      }
    }
  }
}