orte/Robot_Demo/src/org/ocera/orte/demo/HokuyoView.java

   1 package org.ocera.orte.demo;
   2
   3 import java.util.concurrent.locks.ReentrantLock;
   4 import java.util.concurrent.locks.ReentrantReadWriteLock;
   5 import java.util.concurrent.locks.ReentrantReadWriteLock.ReadLock;
   6 import java.util.concurrent.locks.ReentrantReadWriteLock.WriteLock;
   7
   8 import android.content.Context;
   9 import android.graphics.Canvas;
  10 import android.graphics.Color;
  11 import android.graphics.Paint;
  12 import android.graphics.Path;
  13 import android.graphics.Paint.Style;
  14 import android.util.AttributeSet;
  15 import android.view.View;
  16
  17 public class HokuyoView extends View {
  18
  19         public static final double HOKUYO_START_ANGLE = 239.77/2;
  20         public static final int HOKUYO_SPLIT_DIVISION = 1024;
  21         public static final int HOKUYO_ORIENTATION = 1;
  22         public static final double HOKUYO_RANGE_ANGLE_LEFT = 70.0;
  23         public static final double HOKUYO_RANGE_ANGLE_RIGHT = 70.0;
  24
  25         private int[] data = new int[681];
  26         private Paint paint = new Paint();
  27         private Path path = new Path();
  28
  29         private boolean isRunning = false;
  30         private boolean hasBeenDrawn = true;
  31         private final ReentrantLock lock = new ReentrantLock();
  32         private final ReentrantReadWriteLock controlRrwl = new ReentrantReadWriteLock(true);
  33         private final ReadLock rcLock = controlRrwl.readLock();
  34         private final WriteLock wcLock = controlRrwl.writeLock();
  35
  36         public HokuyoView(Context context, AttributeSet attrs) {
  37                 super(context, attrs);
  38
  39                 paint.setStyle(Style.STROKE);
  40                 paint.setStrokeWidth(4);
  41                 paint.setColor(Color.BLACK);
  42                 paint.setAntiAlias(false);
  43         }
  44
  45         @Override
  46         protected void onDraw(Canvas canvas) {
  47                 rcLock.lock();
  48                 try {
  49                         if (isRunning) {
  50                                 lock.lock();
  51                                 try {
  52                                         if (!hasBeenDrawn) {
  53                                                 path.reset();
  54                                                 path.moveTo(getWidth()/2, getHeight());
  55                                                 for(int i = 0; i < data.length; i++) {
  56                                                         double ang = HOKUYO_INDEX_TO_RAD(i);
  57                                                 if((ang<(-HOKUYO_RANGE_ANGLE_LEFT/180.0*Math.PI))||((ang>(HOKUYO_RANGE_ANGLE_RIGHT/180.0*Math.PI)))) {
  58                                                 continue;
  59                                                 }
  60
  61                                                 data[i] /= 10;
  62                                             int x = (int)(getWidth()/2) - (int)(data[i] * Math.sin(HOKUYO_INDEX_TO_RAD(i)));
  63                                             int y = getHeight() -(int)(data[i] * Math.cos(HOKUYO_INDEX_TO_RAD(i)));
  64                                                         path.lineTo(x, y);
  65                                                 }
  66                                                 path.close();
  67                                                 hasBeenDrawn = true;
  68                                         }
  69                                 }
  70                                 finally {
  71                                         lock.unlock();
  72                                 }
  73                         }
  74                         else {
  75                                 path.reset();
  76                         }
  77                         canvas.drawPath(path, paint);
  78                 } finally {
  79                         rcLock.unlock();
  80                 }
  81         }
  82
  83         public void run(boolean run) {
  84                 wcLock.lock();
  85                 try {
  86                         isRunning = run;
  87                 } finally {
  88                         wcLock.unlock();
  89                 }
  90         }
  91
  92         public void setData(int[] data) {
  93                 if (lock.tryLock()) {
  94                         try {
  95                                 this.data = data.clone();
  96                                 hasBeenDrawn = false;
  97                         }
  98                         finally {
  99                                 lock.unlock();
 100                         }
 101                         postInvalidate();
 102                 }
 103         }
 104
 105         public static double HOKUYO_INDEX_TO_DEG(int index) {
 106                 return ((HOKUYO_START_ANGLE-index*360.0/HOKUYO_SPLIT_DIVISION) * HOKUYO_ORIENTATION);
 107         }
 108
 109         public static double HOKUYO_INDEX_TO_RAD(int index) {
 110                 return (HOKUYO_INDEX_TO_DEG(index)/180.0*Math.PI);
 111         }
 112 }