1. Nimm jetzt an unserem Uhans - 3. ADVENT - Gewinnspiel teil - Alle Informationen findest Du hier!

Koordinatensystem für Canvas

Dieses Thema im Forum "Android App Entwicklung" wurde erstellt von BenOtto, 14.09.2010.

  1. BenOtto, 14.09.2010 #1
    BenOtto

    BenOtto Threadstarter Android-Hilfe.de Mitglied

    Beiträge:
    141
    Erhaltene Danke:
    15
    Registriert seit:
    30.08.2010
    Hallo,

    ich suche gerade eine Möglichkeit um das Koordinatensystem der Canvas' bei der Implementierung von onDraw(Canvas) meiner View so zu verbiegen, dass die Y-Achse von unten nach oben verläuft (und nicht umgekehrt).

    Ich habe bei developer.android.com nichtmal eine Definition gefunden, dass das Koordinatensystem so verläuft, wie es verläuft.

    Mein Versuch bisher war:
    PHP:
    @override
    public void onDraw(Canvas canvas) {
        
    // Um View-Höhe nach unten verschieben
        
    canvas.translate(-1f canvas.getHeight0f);
        
    // An X-Achse spiegeln
        
    canvas.scale(1f, -1f);
    }
    Allerdings werden dann Strings bei drawText() gespiegelt dargestellt.

    Hat jemand eine bessere Idee?
     
  2. hahue, 07.10.2010 #2
    hahue

    hahue Neuer Benutzer

    Beiträge:
    4
    Erhaltene Danke:
    0
    Registriert seit:
    07.10.2010
    Dekoriere doch das Canvas Objekt und ev. das View Objekt gleich noch dazu.

    Ist zwar ein wenig Arbeit sollte aber funktionieren.

    lg
    hahue
     
  3. hahue, 07.10.2010 #3
    hahue

    hahue Neuer Benutzer

    Beiträge:
    4
    Erhaltene Danke:
    0
    Registriert seit:
    07.10.2010
    Das View Objekt zu dekorieren stellt sich als etwas "unmöglich" heraus. Es geht aber leichter:

    1. Die entsprechende View von einer bestehenden View ableiten und onDraw überschreiben:

    z.B.
    Code:
    public class DecoratorView extends PlaygroundView {
    
        public DecoratorView(Context context, AttributeSet attrs) {
            super(context, attrs);        
        }
    
        @Override
        protected void onDraw(Canvas canvas) {
            DecoratorCanvas decoCanvas=new DecoratorCanvas(canvas);
            super.onDraw(decoCanvas);
        }
    
    
    }
    
    2. Das Canvas Objekt dekorieren z.B. drawText immer einen String anhängen

    Code:
    package at.genlan.atomic.views;
    
    import javax.microedition.khronos.opengles.GL;
    
    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.Rect;
    import android.graphics.RectF;
    import android.graphics.Region;
    import android.graphics.PorterDuff.Mode;
    import android.graphics.Region.Op;
    
    public class DecoratorCanvas extends Canvas {
        private Canvas decoCanvas=null;
    
        public DecoratorCanvas(Canvas canvas) {        
            super();        
            decoCanvas=canvas;
            // TODO Auto-generated constructor stub
        }
    
        @Override
        public boolean clipPath(Path path, Op op) {
            
            return decoCanvas.clipPath(path, op);
        }
    
        @Override
        public boolean clipPath(Path path) {
            
            return decoCanvas.clipPath(path);
        }
    
        @Override
        public boolean clipRect(float left, float top, float right, float bottom,
                Op op) {
            
            return decoCanvas.clipRect(left, top, right, bottom, op);
        }
    
        @Override
        public boolean clipRect(float f, float f1, float f2, float f3) {
            
            return decoCanvas.clipRect(f, f1, f2, f3);
        }
    
        @Override
        public boolean clipRect(int i, int j, int k, int l) {
            
            return decoCanvas.clipRect(i, j, k, l);
        }
    
        @Override
        public boolean clipRect(Rect rect, Op op) {
            
            return decoCanvas.clipRect(rect, op);
        }
    
        @Override
        public boolean clipRect(Rect rect) {
            
            return decoCanvas.clipRect(rect);
        }
    
        @Override
        public boolean clipRect(RectF rect, Op op) {
            
            return decoCanvas.clipRect(rect, op);
        }
    
        @Override
        public boolean clipRect(RectF rectf) {
            
            return decoCanvas.clipRect(rectf);
        }
    
        @Override
        public boolean clipRegion(Region region, Op op) {
            
            return decoCanvas.clipRegion(region, op);
        }
    
        @Override
        public boolean clipRegion(Region region) {
            
            return decoCanvas.clipRegion(region);
        }
    
        @Override
        public void concat(Matrix matrix) {
            
            decoCanvas.concat(matrix);
        }
    
        @Override
        public void drawArc(RectF oval, float startAngle, float sweepAngle,
                boolean useCenter, Paint paint) {
            
            decoCanvas.drawArc(oval, startAngle, sweepAngle, useCenter, paint);
        }
    
        @Override
        public void drawARGB(int a, int r, int g, int b) {
            
            decoCanvas.drawARGB(a, r, g, b);
        }
    
        @Override
        public void drawBitmap(Bitmap bitmap, float left, float top, Paint paint) {
            
            decoCanvas.drawBitmap(bitmap, left, top, paint);
        }
    
        @Override
        public void drawBitmap(Bitmap bitmap, Matrix matrix, Paint paint) {
            
            decoCanvas.drawBitmap(bitmap, matrix, paint);
        }
    
        @Override
        public void drawBitmap(Bitmap bitmap, Rect src, Rect dst, Paint paint) {
            
            decoCanvas.drawBitmap(bitmap, src, dst, paint);
        }
    
        @Override
        public void drawBitmap(Bitmap bitmap, Rect src, RectF dst, Paint paint) {
            
            decoCanvas.drawBitmap(bitmap, src, dst, paint);
        }
    
        @Override
        public void drawBitmap(int[] colors, int offset, int stride, float x,
                float y, int width, int height, boolean hasAlpha, Paint paint) {
            
            decoCanvas.drawBitmap(colors, offset, stride, x, y, width, height, hasAlpha, paint);
        }
    
        @Override
        public void drawBitmap(int[] colors, int offset, int stride, int x, int y,
                int width, int height, boolean hasAlpha, Paint paint) {
            
            decoCanvas.drawBitmap(colors, offset, stride, x, y, width, height, hasAlpha, paint);
        }
    
        @Override
        public void drawBitmapMesh(Bitmap bitmap, int meshWidth, int meshHeight,
                float[] verts, int vertOffset, int[] colors, int colorOffset,
                Paint paint) {
            
            decoCanvas.drawBitmapMesh(bitmap, meshWidth, meshHeight, verts, vertOffset, colors,
                    colorOffset, paint);
        }
    
        @Override
        public void drawCircle(float cx, float cy, float radius, Paint paint) {
            
            decoCanvas.drawCircle(cx, cy, radius, paint);
        }
    
        @Override
        public void drawColor(int color, Mode mode) {
            
            decoCanvas.drawColor(color, mode);
        }
    
        @Override
        public void drawColor(int color) {
            
            decoCanvas.drawColor(color);
        }
    
        @Override
        public void drawLine(float startX, float startY, float stopX, float stopY,
                Paint paint) {
            
            decoCanvas.drawLine(startX, startY, stopX, stopY, paint);
        }
    
        @Override
        public void drawLines(float[] af, int i, int j, Paint paint) {
            
            decoCanvas.drawLines(af, i, j, paint);
        }
    
        @Override
        public void drawLines(float[] pts, Paint paint) {
            
            decoCanvas.drawLines(pts, paint);
        }
    
        @Override
        public void drawOval(RectF oval, Paint paint) {
            
            decoCanvas.drawOval(oval, paint);
        }
    
        @Override
        public void drawPaint(Paint paint) {
            
            decoCanvas.drawPaint(paint);
        }
    
        @Override
        public void drawPath(Path path, Paint paint) {
            
            decoCanvas.drawPath(path, paint);
        }
    
        @Override
        public void drawPicture(Picture picture, Rect dst) {
            
            decoCanvas.drawPicture(picture, dst);
        }
    
        @Override
        public void drawPicture(Picture picture, RectF dst) {
            
            decoCanvas.drawPicture(picture, dst);
        }
    
        @Override
        public void drawPicture(Picture picture) {
            
            decoCanvas.drawPicture(picture);
        }
    
        @Override
        public void drawPoint(float f, float f1, Paint paint) {
            
            decoCanvas.drawPoint(f, f1, paint);
        }
    
        @Override
        public void drawPoints(float[] af, int i, int j, Paint paint) {
            
            decoCanvas.drawPoints(af, i, j, paint);
        }
    
        @Override
        public void drawPoints(float[] pts, Paint paint) {
            
            decoCanvas.drawPoints(pts, paint);
        }
    
        @Override
        public void drawPosText(char[] text, int index, int count, float[] pos,
                Paint paint) {
            
            decoCanvas.drawPosText(text, index, count, pos, paint);
        }
    
        @Override
        public void drawPosText(String text, float[] pos, Paint paint) {
            
            decoCanvas.drawPosText(text, pos, paint);
        }
    
        @Override
        public void drawRect(float left, float top, float right, float bottom,
                Paint paint) {
            
            decoCanvas.drawRect(left, top, right, bottom, paint);
        }
    
        @Override
        public void drawRect(Rect r, Paint paint) {
            
            decoCanvas.drawRect(r, paint);
        }
    
        @Override
        public void drawRect(RectF rect, Paint paint) {
            
            decoCanvas.drawRect(rect, paint);
        }
    
        @Override
        public void drawRGB(int r, int g, int b) {
            
            decoCanvas.drawRGB(r, g, b);
        }
    
        @Override
        public void drawRoundRect(RectF rect, float rx, float ry, Paint paint) {
            
            decoCanvas.drawRoundRect(rect, rx, ry, paint);
        }
    
        @Override
        public void drawText(char[] text, int index, int count, float x, float y,
                Paint paint) {
            
            decoCanvas.drawText(text, index, count, x, y, paint);
        }
    
        @Override
        public void drawText(CharSequence text, int start, int end, float x,
                float y, Paint paint) {
            
            decoCanvas.drawText(text, start, end, x, y, paint);
        }
    
        @Override
        public void drawText(String s, float f, float f1, Paint paint) {
            
            decoCanvas.drawText(s+"0", f, f1, paint);
        }
    
        @Override
        public void drawText(String text, int start, int end, float x, float y,
                Paint paint) {
            
            decoCanvas.drawText(text, start, end, x, y, paint);
        }
    
        @Override
        public void drawTextOnPath(char[] text, int index, int count, Path path,
                float offset, float offset2, Paint paint) {
            
            decoCanvas.drawTextOnPath(text, index, count, path, offset, offset2, paint);
        }
    
        @Override
        public void drawTextOnPath(String text, Path path, float offset,
                float offset2, Paint paint) {
            
            decoCanvas.drawTextOnPath(text, path, offset, offset2, paint);
        }
    
        @Override
        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) {
            
            decoCanvas.drawVertices(mode, vertexCount, verts, vertOffset, texs, texOffset,
                    colors, colorOffset, indices, indexOffset, indexCount, paint);
        }
    
        @Override
        protected void finalize() throws Throwable {
            
            super.finalize();
        }
    
        @Override
        public boolean getClipBounds(Rect bounds) {
            
            return decoCanvas.getClipBounds(bounds);
        }
    
        @Override
        public int getDensity() {
            
            return decoCanvas.getDensity();
        }
    
        @Override
        public DrawFilter getDrawFilter() {
            
            return decoCanvas.getDrawFilter();
        }
    
        @Override
        public GL getGL() {
            
            return decoCanvas.getGL();
        }
    
        @Override
        public int getHeight() {
            
            return decoCanvas.getHeight();
        }
    
        @Override
        public void getMatrix(Matrix ctm) {
            
            decoCanvas.getMatrix(ctm);
        }
    
        @Override
        public int getSaveCount() {
            
            return decoCanvas.getSaveCount();
        }
    
        @Override
        public int getWidth() {
            
            return decoCanvas.getWidth();
        }
    
        @Override
        public boolean isOpaque() {
            
            return decoCanvas.isOpaque();
        }
    
        @Override
        public boolean quickReject(float left, float top, float right,
                float bottom, EdgeType type) {
            
            return decoCanvas.quickReject(left, top, right, bottom, type);
        }
    
        @Override
        public boolean quickReject(Path path, EdgeType type) {
            
            return decoCanvas.quickReject(path, type);
        }
    
        @Override
        public boolean quickReject(RectF rect, EdgeType type) {
            
            return decoCanvas.quickReject(rect, type);
        }
    
        @Override
        public void restore() {
            
            decoCanvas.restore();
        }
    
        @Override
        public void restoreToCount(int i) {
            
            decoCanvas.restoreToCount(i);
        }
    
        @Override
        public void rotate(float f) {
            
            decoCanvas.rotate(f);
        }
    
        @Override
        public int save() {
            
            return decoCanvas.save();
        }
    
        @Override
        public int save(int i) {
            
            return decoCanvas.save(i);
        }
    
        @Override
        public int saveLayer(float left, float top, float right, float bottom,
                Paint paint, int saveFlags) {
            
            return decoCanvas.saveLayer(left, top, right, bottom, paint, saveFlags);
        }
    
        @Override
        public int saveLayer(RectF bounds, Paint paint, int saveFlags) {
            
            return decoCanvas.saveLayer(bounds, paint, saveFlags);
        }
    
        @Override
        public int saveLayerAlpha(float left, float top, float right, float bottom,
                int alpha, int saveFlags) {
            
            return decoCanvas.saveLayerAlpha(left, top, right, bottom, alpha, saveFlags);
        }
    
        @Override
        public int saveLayerAlpha(RectF bounds, int alpha, int saveFlags) {
            
            return decoCanvas.saveLayerAlpha(bounds, alpha, saveFlags);
        }
    
        @Override
        public void scale(float f, float f1) {
            
            decoCanvas.scale(f, f1);
        }
    
        @Override
        public void setBitmap(Bitmap bitmap) {
            
            decoCanvas.setBitmap(bitmap);
        }
    
        @Override
        public void setDensity(int density) {
            
            decoCanvas.setDensity(density);
        }
    
        @Override
        public void setDrawFilter(DrawFilter filter) {
            
            decoCanvas.setDrawFilter(filter);
        }
    
        @Override
        public void setMatrix(Matrix matrix) {
            
            decoCanvas.setMatrix(matrix);
        }
    
        @Override
        public void setViewport(int width, int height) {
            
            decoCanvas.setViewport(width, height);
        }
    
        @Override
        public void skew(float f, float f1) {
            
            decoCanvas.skew(f, f1);
        }
    
        @Override
        public void translate(float f, float f1) {
            
            decoCanvas.translate(f, f1);
        }
    
    }
    
    
    lg
    hahue
     
  4. BenOtto, 13.10.2010 #4
    BenOtto

    BenOtto Threadstarter Android-Hilfe.de Mitglied

    Beiträge:
    141
    Erhaltene Danke:
    15
    Registriert seit:
    30.08.2010
    Und wieso ist dann das Koordinatensystem anders?
     
  5. hahue, 13.10.2010 #5
    hahue

    hahue Neuer Benutzer

    Beiträge:
    4
    Erhaltene Danke:
    0
    Registriert seit:
    07.10.2010
    Hallo,

    wenn Du die entsprechenden Methoden im Canvas Dekorator umschreibst, dann ist auch das Koordinatensystem anders. Z.B.:

    Code:
        @Override
        public void drawCircle(float cx, float cy, float radius, Paint paint) {
            cy=cy*-1f;
            decoCanvas.drawCircle(cx, cy, radius, paint);
        }
    
    Das machst Du für alle Methoden die Du umgedreht haben möchtest. Und für die Textmethoden lässt Du alles beim Alten.

    lg
    hahue
     
    Zuletzt bearbeitet: 13.10.2010
  6. BenOtto, 13.10.2010 #6
    BenOtto

    BenOtto Threadstarter Android-Hilfe.de Mitglied

    Beiträge:
    141
    Erhaltene Danke:
    15
    Registriert seit:
    30.08.2010
    Das ist aber auch hässlich, weil ja dann für's Text Zeichnen andere Koordinaten benötigt werden.
     
  7. hahue, 13.10.2010 #7
    hahue

    hahue Neuer Benutzer

    Beiträge:
    4
    Erhaltene Danke:
    0
    Registriert seit:
    07.10.2010
    Es wird ja nur die Y Achse (Bezugspunkt) umgekehrt und nicht der Text selbst.
    Daher könntest Du auch für die Textmethoden die Y-Umkehrung verwenden.

    lg
    hahue
     

Diese Seite empfehlen