'나침반'에 해당되는 글 2

  1. 2010.07.31 [iPhone] Compass 구현하기
  2. 2009.07.07 [android] 나침반 + 구글지도
Interesting/iPhone | Posted by hyena0 2010. 7. 31. 23:52

[iPhone] Compass 구현하기



iPhone 에서 나침반을 구현하려고

할 때, 아래와 같은 작업을 수행하면 됩니다.

사용하고자 하는 클래스에서

CLLocationManagerDelegate의 프로토콜

사용을 선언합니다.

CLLocationManagerDelegate 에는 다음의 

메소드가 있습니다. 

- (void)locationManager:(CLLocationManager *)manager didUpdateHeading:(CLHeading *)newHeading


이 메소드를 구현해 주고,  CLLocationManager에서 startUpdatingHeading를 실행시켜주면

구현된 위의 메소드를 실행해서 Heading값을 가져오게 됩니다.

아래는 간단히 예제를 정리해 봅니다.

* header file

#import <XX.h>

#import <XXX.h>

@interface 클래스명 : 슈퍼클래스명 <CLLocationManagerDelegate>{


   .....내용..... 


}


* implementation file 
....

- (void)viewDidLoad { //viewcontroller 라고 가정

        CLLocationManager *locationManager=[[CLLocationManager alloc] init];

locationManager.delegate=self;

locationManager.desiredAccuracy=kCLLocationAccuracyNearestTenMeters;

 

[locationManager startUpdatingHeading];//heading값 호출 시작


.....내용.....


}
....

- (void)locationManager:(CLLocationManager *)manager didUpdateHeading:(CLHeading *)newHeading{

headingData = newHeading.magneticHeading;//heading 값 중 자기장 값 가져오기

NSLog(@"Magnetic heading value : %f", headingData);//로그로 확인


        ...기타 추가 구현....


}


위와 같이 구현하면 headingData 에서 나침반의 각도값을 가져올 수 있습니다.





Interesting/ANDROID | Posted by hyena0 2009. 7. 7. 02:49

[android] 나침반 + 구글지도


  나침반 + 구글지도

  안드로이드에서 구글지도를 

  보이게 하는 것은 검색페이지에서 쉽게 찾을 수 있다.

  안드로이드의 센서 중 하나인

  나침반을 이용해서 구글지도와 연결하면

  핸드폰을 가지고 방향만 틀어도 지도를 볼 수 있게 된다.

  여기서 센서의 방향 값을 가지고 지도를 회전할 수 있게 해야 하는게 관건인데

  아래의 샘플코드를 보면 센서값 중 heading 값을 가지고 평면의 회전 각도를 입력한다.

  아래 코드는 MapViewCompassDemo.java를 수정한 것이다. 

  SDK 1.5 맞게 수정했으므로 한번 시험해 보면 동작을 확인해 볼 수 있다. 

  여기서 중요한 건 MapActivity 로 상속받아 사용할때 Manifest 파일을 수정해야 한다는 것과

  프로젝트 속성에서 Build Target을 Google API로 해놓고 해야 한다는 것이다.

package <<당신의 패키지 이름>>;


import javax.microedition.khronos.opengles.GL;


import android.os.Bundle;

import android.view.MotionEvent;

import android.view.View;

import android.view.ViewGroup;

import android.content.Context;

import android.graphics.Bitmap;

import android.graphics.Canvas;

import android.graphics.DrawFilter;

import android.graphics.Matrix;

import android.graphics.Paint;

import android.graphics.Path;

import android.graphics.Picture;

import android.graphics.PorterDuff;

import android.graphics.Rect;

import android.graphics.RectF;

import android.graphics.Region;

import android.hardware.Sensor;

import android.hardware.SensorManager;

import android.hardware.SensorEventListener;

import android.hardware.SensorEvent;


import com.google.android.maps.MapActivity;

import com.google.android.maps.MapView;

import com.google.android.maps.MyLocationOverlay;


/**

 * Example of how to use an {@link com.google.android.maps.MapView}

 * in conjunction with the {@link com.hardware.SensorManager}

 * <h3>MapViewCompassDemo</h3>


<p>This demonstrates creating a Map based Activity.</p>


<h4>Source files</h4>

 * <table class="LinkTable">

 *         <tr>

 *             <td >src/com/android/samples/view/MapViewCompassDemo.java</td>

 *             <td >The Alert Dialog Samples implementation</td>

 *         </tr>

 * </table>

 */

public class rotatableMap extends MapActivity {


    private SensorManager mSensorManager;

    private RotateView mRotateView;

    private MapView mMapView;

    private MyLocationOverlay mMyLocationOverlay;


    private class RotateView extends ViewGroup implements SensorEventListener {

                                           //v1.5 부터는 SensorEventListener를 이용합니다.

        private static final float SQ2 = 1.414213562373095f;

        private final SmoothCanvas mCanvas = new SmoothCanvas();

        private float mHeading = 0;


        public RotateView(Context context) {

            super(context);

        }


        public void onSensorChanged(SensorEvent sensorEvent) {

            synchronized (this) {

                mHeading = sensorEvent.values[0];  // 센서 값중 Heading 값만 가져갑니다.

                invalidate();

            }

        }

        public void onAccuracyChanged(Sensor sensor, int accuracy){

    }

        

        @Override

        protected void dispatchDraw(Canvas canvas) {

            canvas.save(Canvas.MATRIX_SAVE_FLAG);

            canvas.rotate(-mHeading, getWidth() * 0.5f, getHeight() * 0.5f);

            mCanvas.delegate = canvas;

            super.dispatchDraw(mCanvas);

            canvas.restore();

        }


        @Override

        protected void onLayout(boolean changed, int l, int t, int r, int b) {

            final int width = getWidth();

            final int height = getHeight();

            final int count = getChildCount();

            for (int i = 0; i < count; i++) {

                final View view = getChildAt(i);

                final int childWidth = view.getMeasuredWidth();

                final int childHeight = view.getMeasuredHeight();

                final int childLeft = (width - childWidth) / 2;

                final int childTop = (height - childHeight) / 2;

                view.layout(childLeft, childTop, childLeft + childWidth, childTop + childHeight);

            }

        }



        @Override

        protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {

            int w = getDefaultSize(getSuggestedMinimumWidth(), widthMeasureSpec);

            int h = getDefaultSize(getSuggestedMinimumHeight(), heightMeasureSpec);

            int sizeSpec;

            if (w > h) {

                sizeSpec = MeasureSpec.makeMeasureSpec((int) (w * SQ2), MeasureSpec.EXACTLY);

            } else {

                sizeSpec = MeasureSpec.makeMeasureSpec((int) (h * SQ2), MeasureSpec.EXACTLY);

            }

            final int count = getChildCount();

            for (int i = 0; i < count; i++) {

                getChildAt(i).measure(sizeSpec, sizeSpec);

            }

            super.onMeasure(widthMeasureSpec, heightMeasureSpec);

        }


        @Override

        public boolean dispatchTouchEvent(MotionEvent ev) {

            // TODO: rotate events too

            return super.dispatchTouchEvent(ev);

        }

    }


    @Override

    public void onCreate(Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);


        //original

        //requestWindowFeature(Window.FEATURE_OPENGL);


        mSensorManager = (SensorManager) getSystemService(SENSOR_SERVICE);

        mRotateView = new RotateView(this);

        mMapView = new MapView(this, "06MmQkkJlMQtcbbaAI1Njy1JcO39_F4DrwR-cpA");

        mRotateView.addView(mMapView);

        setContentView(mRotateView);


        mMyLocationOverlay = new MyLocationOverlay(this, mMapView);

        mMyLocationOverlay.runOnFirstFix(new Runnable() { public void run() {

            mMapView.getController().animateTo(mMyLocationOverlay.getMyLocation());

        }});

        mMapView.getOverlays().add(mMyLocationOverlay);

        mMapView.getController().setZoom(18);

        mMapView.setClickable(true);

        mMapView.setEnabled(true);

    }


    @Override

    protected void onResume() {

        super.onResume();

        mSensorManager.registerListener(mRotateView,

        mSensorManager.getDefaultSensor(Sensor.TYPE_ORIENTATION),

                SensorManager.SENSOR_DELAY_UI);

        mMyLocationOverlay.enableMyLocation();

    }


    @Override

    protected void onStop() {

        mSensorManager.unregisterListener(mRotateView);

        mMyLocationOverlay.disableMyLocation();

        super.onStop();

    }


    @Override

    protected boolean isRouteDisplayed() {

        return false;

    }



    static final class SmoothCanvas extends Canvas {

        Canvas delegate;


        private final Paint mSmooth = new Paint(Paint.FILTER_BITMAP_FLAG);


        public void setBitmap(Bitmap bitmap) {

            delegate.setBitmap(bitmap);

        }


        public void setViewport(int width, int height) {

            delegate.setViewport(width, height);

        }


        public boolean isOpaque() {

            return delegate.isOpaque();

        }


        public int getWidth() {

            return delegate.getWidth();

        }


        public int getHeight() {

            return delegate.getHeight();

        }


        public int save() {

            return delegate.save();

        }


        public int save(int saveFlags) {

            return delegate.save(saveFlags);

        }


        public int saveLayer(RectF bounds, Paint paint, int saveFlags) {

            return delegate.saveLayer(bounds, paint, saveFlags);

        }


        public int saveLayer(float left, float top, float right, float

                bottom, Paint paint,

                int saveFlags) {

            return delegate.saveLayer(left, top, right, bottom, paint,

                    saveFlags);

        }


        public int saveLayerAlpha(RectF bounds, int alpha, int saveFlags) {

            return delegate.saveLayerAlpha(bounds, alpha, saveFlags);

        }


        public int saveLayerAlpha(float left, float top, float right,

                float bottom, int alpha,

                int saveFlags) {

            return delegate.saveLayerAlpha(left, top, right, bottom,

                    alpha, saveFlags);

        }


        public void restore() {

            delegate.restore();

        }


        public int getSaveCount() {

            return delegate.getSaveCount();

        }


        public void restoreToCount(int saveCount) {

            delegate.restoreToCount(saveCount);

        }


        public void translate(float dx, float dy) {

            delegate.translate(dx, dy);

        }


        public void scale(float sx, float sy) {

            delegate.scale(sx, sy);

        }


        public void rotate(float degrees) {

            delegate.rotate(degrees);

        }


        public void skew(float sx, float sy) {

            delegate.skew(sx, sy);

        }


        public void concat(Matrix matrix) {

            delegate.concat(matrix);

        }


        public void setMatrix(Matrix matrix) {

            delegate.setMatrix(matrix);

        }


        public void getMatrix(Matrix ctm) {

            delegate.getMatrix(ctm);

        }


        public boolean clipRect(RectF rect, Region.Op op) {

            return delegate.clipRect(rect, op);

        }


        public boolean clipRect(Rect rect, Region.Op op) {

            return delegate.clipRect(rect, op);

        }


        public boolean clipRect(RectF rect) {

            return delegate.clipRect(rect);

        }


        public boolean clipRect(Rect rect) {

            return delegate.clipRect(rect);

        }


        public boolean clipRect(float left, float top, float right,

                float bottom, Region.Op op) {

            return delegate.clipRect(left, top, right, bottom, op);

        }


        public boolean clipRect(float left, float top, float right,

                float bottom) {

            return delegate.clipRect(left, top, right, bottom);

        }


        public boolean clipRect(int left, int top, int right, int bottom) {

            return delegate.clipRect(left, top, right, bottom);

        }


        public boolean clipPath(Path path, Region.Op op) {

            return delegate.clipPath(path, op);

        }


        public boolean clipPath(Path path) {

            return delegate.clipPath(path);

        }


        public boolean clipRegion(Region region, Region.Op op) {

            return delegate.clipRegion(region, op);

        }


        public boolean clipRegion(Region region) {

            return delegate.clipRegion(region);

        }


        public DrawFilter getDrawFilter() {

            return delegate.getDrawFilter();

        }


        public void setDrawFilter(DrawFilter filter) {

            delegate.setDrawFilter(filter);

        }


        public GL getGL() {

            return delegate.getGL();

        }


        public boolean quickReject(RectF rect, EdgeType type) {

            return delegate.quickReject(rect, type);

        }


        public boolean quickReject(Path path, EdgeType type) {

            return delegate.quickReject(path, type);

        }


        public boolean quickReject(float left, float top, float right,

                float bottom,

                EdgeType type) {

            return delegate.quickReject(left, top, right, bottom, type);

        }


        public boolean getClipBounds(Rect bounds) {

            return delegate.getClipBounds(bounds);

        }


        public void drawRGB(int r, int g, int b) {

            delegate.drawRGB(r, g, b);

        }


        public void drawARGB(int a, int r, int g, int b) {

            delegate.drawARGB(a, r, g, b);

        }


        public void drawColor(int color) {

            delegate.drawColor(color);

        }


        public void drawColor(int color, PorterDuff.Mode mode) {

            delegate.drawColor(color, mode);

        }


        public void drawPaint(Paint paint) {

            delegate.drawPaint(paint);

        }


        public void drawPoints(float[] pts, int offset, int count,

                Paint paint) {

            delegate.drawPoints(pts, offset, count, paint);

        }


        public void drawPoints(float[] pts, Paint paint) {

            delegate.drawPoints(pts, paint);

        }


        public void drawPoint(float x, float y, Paint paint) {

            delegate.drawPoint(x, y, paint);

        }


        public void drawLine(float startX, float startY, float stopX,

                float stopY, Paint paint) {

            delegate.drawLine(startX, startY, stopX, stopY, paint);

        }


        public void drawLines(float[] pts, int offset, int count, Paint paint) {

            delegate.drawLines(pts, offset, count, paint);

        }


        public void drawLines(float[] pts, Paint paint) {

            delegate.drawLines(pts, paint);

        }


        public void drawRect(RectF rect, Paint paint) {

            delegate.drawRect(rect, paint);

        }


        public void drawRect(Rect r, Paint paint) {

            delegate.drawRect(r, paint);

        }


        public void drawRect(float left, float top, float right, float

                bottom, Paint paint) {

            delegate.drawRect(left, top, right, bottom, paint);

        }


        public void drawOval(RectF oval, Paint paint) {

            delegate.drawOval(oval, paint);

        }


        public void drawCircle(float cx, float cy, float radius, Paint paint) {

            delegate.drawCircle(cx, cy, radius, paint);

        }


        public void drawArc(RectF oval, float startAngle, float

                sweepAngle, boolean useCenter,

                Paint paint) {

            delegate.drawArc(oval, startAngle, sweepAngle, useCenter, paint);

        }


        public void drawRoundRect(RectF rect, float rx, float ry, Paint paint) {

            delegate.drawRoundRect(rect, rx, ry, paint);

        }


        public void drawPath(Path path, Paint paint) {

            delegate.drawPath(path, paint);

        }


        public void drawBitmap(Bitmap bitmap, float left, float top,

                Paint paint) {

            if (paint == null) {

                paint = mSmooth;

            } else {

                paint.setFilterBitmap(true);

            }

            delegate.drawBitmap(bitmap, left, top, paint);

        }


        public void drawBitmap(Bitmap bitmap, Rect src, RectF dst,

                Paint paint) {

            if (paint == null) {

                paint = mSmooth;

            } else {

                paint.setFilterBitmap(true);

            }

            delegate.drawBitmap(bitmap, src, dst, paint);

        }


        public void drawBitmap(Bitmap bitmap, Rect src, Rect dst, Paint paint) {

            if (paint == null) {

                paint = mSmooth;

            } else {

                paint.setFilterBitmap(true);

            }

            delegate.drawBitmap(bitmap, src, dst, paint);

        }


        public void drawBitmap(int[] colors, int offset, int stride,

                int x, int y, int width,

                int height, boolean hasAlpha, Paint paint) {

            if (paint == null) {

                paint = mSmooth;

            } else {

                paint.setFilterBitmap(true);

            }

            delegate.drawBitmap(colors, offset, stride, x, y, width,

                    height, hasAlpha, paint);

        }


        public void drawBitmap(Bitmap bitmap, Matrix matrix, Paint paint) {

            if (paint == null) {

                paint = mSmooth;

            } else {

                paint.setFilterBitmap(true);

            }

            delegate.drawBitmap(bitmap, matrix, paint);

        }


        public void drawBitmapMesh(Bitmap bitmap, int meshWidth, int

                meshHeight, float[] verts,

                int vertOffset, int[] colors, int colorOffset, Paint paint) {

            delegate.drawBitmapMesh(bitmap, meshWidth, meshHeight,

                    verts, vertOffset, colors,

                    colorOffset, paint);

        }


        public void drawVertices(VertexMode mode, int vertexCount,

                float[] verts, int vertOffset,

                float[] texs, int texOffset, int[] colors, int

                colorOffset, short[] indices,

                int indexOffset, int indexCount, Paint paint) {

            delegate.drawVertices(mode, vertexCount, verts,

                    vertOffset, texs, texOffset, colors,

                    colorOffset, indices, indexOffset, indexCount, paint);

        }


        public void drawText(char[] text, int index, int count, float

                x, float y, Paint paint) {

            delegate.drawText(text, index, count, x, y, paint);

        }


        public void drawText(String text, float x, float y, Paint paint) {

            delegate.drawText(text, x, y, paint);

        }


        public void drawText(String text, int start, int end, float x,

                float y, Paint paint) {

            delegate.drawText(text, start, end, x, y, paint);

        }


        public void drawText(CharSequence text, int start, int end,

                float x, float y, Paint paint) {

            delegate.drawText(text, start, end, x, y, paint);

        }


        public void drawPosText(char[] text, int index, int count,

                float[] pos, Paint paint) {

            delegate.drawPosText(text, index, count, pos, paint);

        }


        public void drawPosText(String text, float[] pos, Paint paint) {

            delegate.drawPosText(text, pos, paint);

        }


        public void drawTextOnPath(char[] text, int index, int count,

                Path path, float hOffset,

                float vOffset, Paint paint) {

            delegate.drawTextOnPath(text, index, count, path, hOffset,

                    vOffset, paint);

        }


        public void drawTextOnPath(String text, Path path, float

                hOffset, float vOffset,

                Paint paint) {

            delegate.drawTextOnPath(text, path, hOffset, vOffset, paint);

        }


        public void drawPicture(Picture picture) {

            delegate.drawPicture(picture);

        }


        public void drawPicture(Picture picture, RectF dst) {

            delegate.drawPicture(picture, dst);

        }


        public void drawPicture(Picture picture, Rect dst) {

            delegate.drawPicture(picture, dst);

        }

    }

}