지도정보를 좌표정보로 변환하기

지도 정보는 위도와 경도로 표시됩니다.

위도는 적도 중심으로 북극 혹은 남극까지

+90도, -90도의 값을 가지고,

경도는 그리니치 천문대 기준으로 동서로

 +180도, -180도 값을 가집니다.

이 위도 및 경도 값을 좌표 값으로 변환하려면 구면 좌표계에 대한 이해가 필요합니다.

그 이유는 아래 그림과 같습니다.



우선 변환하고자 하는 값은 원의 "호" 에 해당하는 값이라서 반지름이 R이고, 각도가 theta라고 하면

호는 R * theta 가 됩니다.

이제 위도 값을 보자면 +-90도 이므로 그냥 각도를 계산하면 됩니다.

하지만 그림에서와 같이 위도 값은 구에서 자른 절단면에 대한 원의 반지름이 달라지기 때문에

계산법이 달라집니다. 그냥 각도값을 가지는게 아니라 R * (phi) * cos(theta)  가 되는 것이지요.

그리고 지도 정보를 코드에 적용한다고 할때, 저의 경우는 

"내 위치" 기준으로 생각해서 좌표계를 재설정 하는 방식을 취했습니다.

그러므로 구할 수 있는 위도, 경도 좌표값을 내 위치로부터 차 값을 구하고

위의 그림에서와 같이 평면 좌표로 변환하는 것입니다.

예제 코드는 아래와 같습니다.

.....
                lngLat = pairs[i].split(",");

        lat_angle = Double.parseDouble(lngLat[1]);//*1E6;

        delx = Double.parseDouble(lngLat[0]) - (geoOverlay.gslongitude / 1E6); // longitude 의 차이값을 구함

        dely = Double.parseDouble(lngLat[1]) - (geoOverlay.gslatitude / 1E6); // latitude 의 차이값을 구함

        

        var[j] = earthR * delx * (Math.PI/180) * Math.cos(lat_angle/180*Math.PI);

        var[j+1] = earthR * dely * (Math.PI/180);

......

코드 상에서 "Math.PI/180" 처럼 PI값이 3.14 인 라디안 값인데, 수학적인 함수를 사용할때 라디안 값으로 변환되므로 

180도를 나누어 차원을 변환해주기 위해 처리한 부분입니다. 


Publish 후에 MAP blank 문제

안드로이드의 어플을 맵 API 를 이용할 경우

마켓에 등록하기 전에 확인해야 할 것이 있습니다.

보통 MAP API의 인증 키를 받기 위해

http://code.google.com/intl/ko-KR/android/maps-api-signup.html

이곳에서 다음의 명령을 사용해서 MD5 값을 승인받는데요.


$ keytool -list -keystore ~/.android/debug.keystore
...
Certificate fingerprint (MD5): 94:1E:43:49:87:73:BB:E6:A6:88:D7:20:F1:8E:B5:98


마켓에 publish 하려면 어플 자체를 키로 암호화 해야 하는 것처럼

지도의 MAP API 도 암호화 해야 합니다.

그렇게 하지 않으면 마켓에서 다운로드 받았을 때 공백으로 보이더군요.

keytool을 이용하여 암호화하는 방법은 다음과 같습니다.

C:>D:\Programme\dev\Java\jdk1.6.0_07\bin\keytool -list -alias androiddebugkey -keystore C:\Users\plusminus\AppData\Local\Android\debug.keystore -storepass android -keypass android 
androiddebugkey, 13.10.2008, PrivateKeyEntry, 
Zertifikatsfingerabdruck (MD5): E1:XX:XX:XX:XX:XX:XX:XX:XX:XX:XX:XX:XX:XX:XX:BC

해당 내용은 anddev.org 에서 참조 했습니다.
Interesting/ANDROID | Posted by hyena0 2009.07.07 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);

        }

    }

}