Koordinatensystem für Canvas

B

BenOtto

Fortgeschrittenes Mitglied
15
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.getHeight, 0f);
    // An X-Achse spiegeln
    canvas.scale(1f, -1f);
}

Allerdings werden dann Strings bei drawText() gespiegelt dargestellt.

Hat jemand eine bessere Idee?
 
Dekoriere doch das Canvas Objekt und ev. das View Objekt gleich noch dazu.

Ist zwar ein wenig Arbeit sollte aber funktionieren.

lg
hahue
 
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
 
Und wieso ist dann das Koordinatensystem anders?
 
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:
Das ist aber auch hässlich, weil ja dann für's Text Zeichnen andere Koordinaten benötigt werden.
 
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
 
Du musst dich einloggen oder registrieren, um hier zu antworten.

Ähnliche Themen

netfreak
App für Benachrichtigungen lesen
  • netfreak
Antworten
10
Aufrufe
456
netfreak
netfreak
5
Android Studio Plugin erstellen für Lokalisierung
  • 586920
Antworten
0
Aufrufe
1.145
586920
5
Y
Welchen Account Typen für Entwickler Konto Registrierung bei Microsoft?
  • youki
Antworten
4
Aufrufe
1.222
swa00
swa00
Zurück
Oben Unten