Dirty Rechtecke

Wo kann man finden, Verweise auf die Implementierung eines Algorithmus zur Berechnung eines "dirty rectangle" für die Minimierung der frame-buffer updates? Ein display-Modell, die es erlaubt beliebige änderungen und berechnet die minimale Anzahl von "bit blit" Operationen erforderlich, um die Anzeige zu aktualisieren.

Eine Klärung der Sprache, Plattform und use-case, würde es ermöglichen, diese Frage zu beantworten, in eine weitere nützliche Art und Weise.
Die bounding-box-tag kann helfen.

InformationsquelleAutor | 2008-09-16

Vexi ist eine Referenz-Implementierung dieser. Die Klasse ist org.vexi.util.DirtyList (Apache-Lizenz), und wird als Bestandteil von Produktionssystemen, d.h. gründlich getestet und ist gut kommentiert.

Einen VORBEHALT, die derzeit Klasse Beschreibung ist ein bisschen ungenau, "Ein Allzweck-Daten-Struktur zum halten einer Liste von rechteckigen Regionen, die müssen neu lackiert werden, mit intelligenten Koaleszenz." Eigentlich ist es derzeit noch nicht die Koaleszenz. Daher betrachten Sie diese eine grundlegende DirtyList Implementierung, dass es nur schneidet dirty () - Anfragen um sicherzustellen, gibt es keine überschneidungen dirty Regionen.

Die eine nuance zu dieser Umsetzung ist, dass, anstelle der Verwendung von Rect-oder anderen ähnlichen region-Objekt, die Regionen, die gespeichert sind in ein array von ints, d.h. in Blöcken von 4 ints in ein 1-dimensionales array. Dies geschieht zur Laufzeit, Effizienz, obwohl im Nachhinein bin ich nicht sicher, ob es viel Verdienst. (Ja, ich habe es umgesetzt.) Es sollte einfach genug zu ersetzen Rect für die array-Blöcken im Einsatz.

Den Zweck der Klasse ist, werden schnell. Mit Vexi, schmutzig bezeichnet werden kann bis zu tausend mal pro frame, also die Schnittpunkte der schmutzigen Regionen mit den schmutzigen Anfrage so schnell wie möglich. Nicht mehr als 4 Anzahl Vergleiche werden verwendet, um die relative position der beiden Regionen.

Es ist nicht ganz optimal wegen der fehlenden Koaleszenz. Während Sie es tut, damit keine überschneidungen zwischen verschmutzt/bemalt Regionen, Sie könnten am Ende mit Regionen, die line up und konnten zusammengeführt werden, in einer größeren region - und damit die Reduzierung der Anzahl der paint-Aufrufe.

Code-snippet. Vollständige code hier online.

public class DirtyList {

    /** The dirty regions (each one is an int[4]). */
    private int[] dirties = new int[10 * 4]; //gets grown dynamically

    /** The number of dirty regions */
    private int numdirties = 0;

    ...

    /** 
     *  Pseudonym for running a new dirty() request against the entire dirties list
     *  (x,y) represents the topleft coordinate and (w,h) the bottomright coordinate 
     */
    public final void dirty(int x, int y, int w, int h) { dirty(x, y, w, h, 0); }

    /** 
     *  Add a new rectangle to the dirty list; returns false if the
     *  region fell completely within an existing rectangle or set of
     *  rectangles (i.e. did not expand the dirty area)
     */
    private void dirty(int x, int y, int w, int h, int ind) {
        int _n;
        if (w<x || h<y) {
            return;
        }
        for (int i=ind; i<numdirties; i++) {
            _n = 4*i;
            //invalid dirties are marked with x=-1
            if (dirties[_n]<0) {
                continue;
            }

            int _x = dirties[_n];
            int _y = dirties[_n+1];
            int _w = dirties[_n+2];
            int _h = dirties[_n+3];

            if (x >= _w || y >= _h || w <= _x || h <= _y) {
                //new region is outside of existing region
                continue;
            }

            if (x < _x) {
                //new region starts to the left of existing region

                if (y < _y) {
                    //new region overlaps at least the top-left corner of existing region

                    if (w > _w) {
                        //new region overlaps entire width of existing region

                        if (h > _h) {
                            //new region contains existing region
                            dirties[_n] = -1;
                            continue;
                        }//else {
                        //new region contains top of existing region
                        dirties[_n+1] = h;
                        continue;

                    } else {
                        //new region overlaps to the left of existing region

                        if (h > _h) {
                            //new region contains left of existing region
                            dirties[_n] = w;
                            continue;
                        }//else {
                        //new region overlaps top-left corner of existing region
                        dirty(x, y, w, _y, i+1);
                        dirty(x, _y, _x, h, i+1);
                        return;

                    }
                } else {
                    //new region starts within the vertical range of existing region

                    if (w > _w) {
                        //new region horizontally overlaps existing region

                        if (h > _h) {
                            //new region contains bottom of existing region
                            dirties[_n+3] = y;
                            continue;
                        }//else {
                        //new region overlaps to the left and right of existing region
                        dirty(x, y, _x, h, i+1);
                        dirty(_w, y, w, h, i+1);
                        return;

                    } else {
                        //new region ends within horizontal range of existing region

                        if (h > _h) {
                            //new region overlaps bottom-left corner of existing region
                            dirty(x, y, _x, h, i+1);
                            dirty(_x, _h, w, h, i+1);
                            return;
                        }//else {
                        //existing region contains right part of new region
                        w = _x;
                        continue;
                    }
                }
            } else {
                //new region starts within the horizontal range of existing region

                if (y < _y) {
                    //new region starts above existing region

                    if (w > _w) {
                        //new region overlaps at least top-right of existing region

                        if (h > _h) {
                            //new region contains the right of existing region
                            dirties[_n+2] = x;
                            continue;
                        }//else {
                        //new region overlaps top-right of existing region
                        dirty(x, y, w, _y, i+1);
                        dirty(_w, _y, w, h, i+1);
                        return;

                    } else {
                        //new region is horizontally contained within existing region

                        if (h > _h) {
                            //new region overlaps to the above and below of existing region
                            dirty(x, y, w, _y, i+1);
                            dirty(x, _h, w, h, i+1);
                            return;
                        }//else {
                        //existing region contains bottom part of new region
                        h = _y;
                        continue;
                    }
                } else {
                    //new region starts within existing region

                    if (w > _w) {
                        //new region overlaps at least to the right of existing region

                        if (h > _h) {
                            //new region overlaps bottom-right corner of existing region
                            dirty(x, _h, w, h, i+1);
                            dirty(_w, y, w, _h, i+1);
                            return;
                        }//else {
                        //existing region contains left part of new region
                        x = _w;
                        continue;
                    } else {
                        //new region is horizontally contained within existing region

                        if (h > _h) {
                            //existing region contains top part of new region
                            y = _h;
                            continue;
                        }//else {
                        //new region is contained within existing region
                        return;
                    }
                }
            }
        }

        //region is valid; store it for rendering
        _n = numdirties*4;
        size(_n);
        dirties[_n] = x;
        dirties[_n+1] = y;
        dirties[_n+2] = w;
        dirties[_n+3] = h;
        numdirties++;
    }

    ...
}

InformationsquelleAutor Charles Goodwin

3

Bauen das kleinste Rechteck, das enthält alle Bereiche, die müssen neu lackiert werden:
- Beginnen Sie mit einem leeren Bereich (vielleicht ein Rechteck festgelegt 0,0,0,0 - sowas kann man erkennen, da "kein update erforderlich")
Für jeden dirty-Bereich Hinzugefügt:
- Normalisieren den neuen Bereich (d.h. sicherzustellen, dass Links weniger als rechts, oben weniger als unten)
- Wenn das dirty Rechteck ist derzeit leer, legen Sie es auf der mitgelieferten Bereich
- Andernfalls, setzen Sie die left und top Koordinaten des dirty rectangle " der kleinste {dreckig,neu}, und die rechten und unteren Koordinaten der größte {dreckig,neu}.
Windows, zumindest, unterhält eine update region von den änderungen, dass es schon informiert, und alle Malerarbeiten, die getan werden muss, um durch das Fenster verdeckt und enthüllt. Ein region ist ein Objekt, das aus vielen, möglicherweise diskontinuierliche Rechtecke, Polygone und Ellipsen. Teilen Sie Windows mit, über einen Teil des Bildschirms, muss neu lackiert werden InvalidateRect aufrufen - dort ist auch ein InvalidateRgn Funktion für kompliziertere Bereiche. Wenn Sie wählen, um zu tun einige Gemälde, bevor die nächste WM_PAINT-Nachricht eintrifft, und die Sie ausschließen möchten, dass von der schmutzigen Umgebung, es sind ValidateRect und ValidateRgn Funktionen.

Wenn Sie mit dem malen beginnen mit BeginPaint geben Sie eine PAINTSTRUCT, die Windows füllt sich mit Informationen darüber, was muss gestrichen werden. Eines der Mitglieder ist das kleinste Rechteck, das mit der ungültigen region. Sie können die region selbst mit GetUpdateRgn (müssen Sie dies vor BeginPaint, weil BeginPaint markiert das gesamte Fenster als gültig), wenn Sie möchten, minimieren Sie die Zeichnung, wenn es mehrere kleine ungültig Bereichen.

Ich würde davon ausgehen, dass, wie die Minimierung der Zeichnung war wichtig auf dem Mac und auf X, wenn diese Umgebungen wurden ursprünglich geschrieben, es gibt gleichwertige Mechanismen für die Aufrechterhaltung einer update-region.

"wenn diese Umgebungen wurden ursprünglich geschrieben" - ich denke, es hat immer und wird immer wichtig sein, als der window manager ist ein sehr Häufig verwendeter, semi-low-level-code, den Sie ausführen möchten so schnell wie möglich.

InformationsquelleAutor Mike Dimmick
3

Es klingt wie das, was Sie brauchen, ist ein Begrenzungsrahmen für jede Form, die Sie sind-rendering auf dem Bildschirm. Denken Sie daran, dass eine bounding box eines Polygons kann definiert werden als "Links unten" (das minimum) und ein "oben rechts" (der höchste Punkt). Das heißt, die x-Komponente in dem minimalen Punkt ist definiert als das minimum aller x-Komponenten von jedem Punkt in einem polygon. Verwenden Sie die gleiche Methode für die y-Komponente (im Falle von 2D -) und der maximale Punkt der bounding box.

Wenn es reicht, eine bounding-box (aka "dirty rectangle") pro polygon, sind Sie fertig. Wenn Sie eine Allgemeine zusammengesetzten Begrenzungsbox können Sie den gleichen Algorithmus gilt, es sei denn Sie können einfach füllen Sie einen Karton mit minimalen und maximalen Punkte.

Nun, wenn du alles in Java, können Sie sich Ihre bounding box für eine Area (die Sie bauen können von jedem Shape) direkt mit der getBound2D() Methode.

InformationsquelleAutor Bob Cross
2

Welche Sprache verwenden Sie? In Python, Pygame kann dies für Sie tun. Verwenden Sie die RenderUpdates Gruppe und einige Sprite-Objekte mit Bild und die rect Attribute.

Beispiel:
```
#!/usr/bin/env python
import pygame

class DirtyRectSprite(pygame.sprite.Sprite):
    """Sprite with image and rect attributes."""
    def __init__(self, some_image, *groups):
        pygame.sprite.Sprite.__init__(self, *groups)
        self.image = pygame.image.load(some_image).convert()
        self.rect = self.image.get_rect()
    def update(self):
        pass #do something here

def main():
    screen = pygame.display.set_mode((640, 480))
    background = pygame.image.load(open("some_bg_image.png")).convert()
    render_group = pygame.sprite.RenderUpdates()
    dirty_rect_sprite = DirtyRectSprite(open("some_image.png"))
    render_group.add(dirty_rect_sprite)

    while True:
        dirty_rect_sprite.update()
        render_group.clear(screen, background)
        pygame.display.update(render_group.draw(screen))
```
Wenn Sie nicht mit Python+Pygame, hier ist was ich tun würde:
- Eine Sprite-Klasse, die die update(),
  move() etc. Methode setzt eine "dirty"
  flag.
- Halten Sie ein Rechteck für jedes sprite
- Wenn Ihre API unterstützt die Aktualisierung einer Liste von rects, verwenden, die auf der Liste der rects, deren sprites sind schmutzig. In SDL, das ist SDL_UpdateRects.
- Wenn Ihre API nicht unterstützen, aktualisieren eine Liste von rects (ich hatte nie die chance, auf alles außer SDL, so würde ich nicht wissen), testen, um zu sehen, ob es schneller aufrufen, die blit-Funktion mehrmals oder einmal mit einem großen Rechteck. Ich bezweifle, dass jeder API wäre schneller mit einem großen rect, aber wieder, ich habe nicht alles verwendet neben SDL.
InformationsquelleAutor Martin W
2

Ich erst vor kurzem schrieb eine Delphi-Klasse zum berechnen der Differenz Rechtecke von zwei Bildern, und war ziemlich überrascht, wie schnell er lief, schnell genug zu laufen, in einem kurzen timer und nach Maus - /Tastatur-Nachrichten für die Aufzeichnung Bildschirm Aktivität.

Schritt für Schritt den Kern, wie es funktioniert:
1. Sub-Aufteilung des Bildes in logische 12x12 durch Rechtecke.
2. Schleife durch jedes pixel und wenn es einen Unterschied dann erzähle ich die sub-Rechteck, welches das pixel gehört, dass es einen Unterschied in einem der Pixel und wo.
3. Jedes sub-Rechteck merkt sich die Koordinaten der eigenen linken, oberen, rechten und unteren Unterschied.
4. Sobald alle Unterschiede gefunden wurden, habe ich eine Schleife durch alle sub-Rechtecke, die Unterschiede und bilden größere Rechtecke aus Ihnen heraus, wenn Sie stehen neben einander, und verwenden Sie die am weitesten Links, am weitesten oben, rechts und unten-die meisten Unterschiede dieser sub-Rechtecke zur tatsächlichen Unterschied Rechtecke, die ich benutze.
Diese scheint zu funktionieren ziemlich gut für mich. Wenn Sie nicht bereits implementiert Ihre eigene Lösung, lassen Sie mich wissen, und ich werde E-Mail Sie meinen code, wenn Sie möchten. Auch jetzt, ich bin ein neuer Benutzer von StackOverflow so dass, wenn Sie schätzen meine Antwort dann bitte Stimmen Sie bis. 🙂

InformationsquelleAutor CodeAndCats
2

Blick in Der R-tree und quadtree Datenstrukturen.

InformationsquelleAutor xan

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.