LowLevelGraphicsLibrary

Ganz nett, aber man könnte die Lib noch etwas mehr in Richtung OO bringen. Alle Filter sind einfache statische Funktionen. Kann es sein, dass du die aus einer ehemaligen C Library konvertiert hast?
Die Filter könnte man übrigens prima als Plugin in Paint.NET integrieren  http://www.eecs.wsu.edu/paint.net/

irgendwie mekkert #Develop rum, wenn ich versuche den kram zu Kompilieren:

Zitat:

PFAD\cImageFilters.cs(35,4): error CS0227: Nicht gesicherter Code wird nur angezeigt, wenn mit '/unsafe' kompiliert wird

Das kommt überall da vor wo mit unsafe {} gearbeitet wurde.
Beim Kompilieren wird nur die .manifest Datei erstellt.
Wie kann ich das Lösen?

ok, sorry, da hab ich ja auch schon geguckt, ich hab die Option nur übersehen...

Hallo!

Nächste Frage:
Wo ist der Unterschied zwischen cGraphics.cs und cImageFilters.cs (ist eine davon schneller oder genauer)?

@ErfinderDesRades:

EDIT 18.12.2009: Das komplette Projekt kann im 1. Thread heruntergeladen werden.

EDIT 18.12.2009:

Das Projekt wird immer hier im 1. Post dieses Threads hochgeladen.
Es ist aber immer noch kein endgültiges Release angesagt.

Ich stelle einfach hier die Prerelease-Versionen zur Verfügung.

Hier noch zum Vergleich das Originalbild:

Hier ein Screenshot dazu:

Screenshot1.jpg

Ich muss dir ein großes Kompliment machen, die Bibliothek ist einfach genial :)

Habe heute ein erstes Prerelease veröffentlicht. Damit man sich den Code schon mal anschauen kann. Und nein, der Code bleibt nicht so. An vielen Stellen wird es noch Änderungen und Optimierungen geben.

Die Syntax der Filter bleibt so.

Es wird noch ein ExecuteCloned hinzukommen, bei dem man das bearbeitete Bitmap als Ergebnis erhalten wird und das Original-Bild bleibt dabei wie es ist.

Die Beschreibung der Filter werde ich heute noch hier online stellen:

[EDIT] die erste Anleitung ließ sich nicht online laden, deshalb bis ich wieder dazu komme wird es noch wohl eine Weile dauern.

Neues Prerelease erstellt.

Unter anderem funktionieren jetzt:

- Houghtransform
- Moravec
- ZeroCrossing
- AdaptiveThresholding

Funtionen in ColorFunctions:

u.a.
- Mul(Color, Color)
- Sub (Color, Color)
- Div(Color, Color)

EDIT: noch nicht hochgeladen

Hm sieht ganz interessant aus. Muss ich mir mal anschauen.

PS: Ich suche noch nach einer Funktion die weiße Ränder an Grafiken entfernen kann falls dir da was einfallen sollte

Die Bibliothek ist eigentlich ausgelegt für Stills (Einzelbilder), nicht für Videobearbeitung

- Viele kleine Korrekturen (Fehlende Konstruktoren, Falsche Berechnungen, fehlende Benutzung von UnsafeBitmap und dazugehöriges UnsafeBitmap.Dispose() an manchen Stellen )

- Autocrop ist jetzt rudimentär implementiert, kann benutzt werden.
Funktioniert fürs erste IMHO relativ gut.

- Korrektur von Umrechnungen für Farbmodelle und redundante Farbmodelle entfernt

- Alle vorgesehenen Filter zum Funktionieren gebracht

- Objektextraktor begonnen

Es gibt jetzt im wesentlichen 4 Komponentenarten:

- Extractors (Klassen um bestimmte Features/Objekt usw. zu extrahieren)
- Colorspaces (Farbräume)
- Filter (z.B. Farbfilter-, Morphologie-, Kanten-, Eck-Filter usw.)
- Histogramm und Statistikfunktionen

(- sowie Hilfsfunktionen (BitmapFunctions, ColorFunctions))

@ErfinderDesRades:

Das ist nicht mehr so, dass die meisten Filter Convolution-Filter sind.

Außerdem werde ich einige Filter sowieso zusammenfassen (Es macht z.B. keinen Sinn einen Filter Contours und einen Contours-Filter zu haben.)

Außerdem sind die Filter von BaseImageFilter abgeleitet und haben die eigene Schnittstelle IFilter. So kann also jeder seinen eigenen Filter kreieren und hinzufügen.

Außerdem veröffentliche ich hier einfach die Fortschritte damit jeder damit arbeiten kann.

z.B. gibt es auch noch keine sinnvolle Namespace-Aufteilung, die IMHO aber inzwischen nötig ist. z.B. in Convolution, Morphology, Color usw.

Bis dahin. ;-) Viel Spass damit.

Probiers doch einfach mal aus.

Nach Weihnachten, werde ich diese Version veröffentlichen:


Dann können einige dieser Extraktoren benutzt werden.

- Impainter: kann benutzt werden, um ein Bild zu restaurieren
- Freistellungstool: kann benutzt werden, um Bereiche eines Bildes über eine Maske freizustellen

- AutoCrop: Wird benutzt, um ein Bild vollautomisch auszuschneiden (unwichtige Bereiche werden abgeschnitten)

Bei Vorschau wird ein rotes Rechteck in das Bild eingeblendet.

- Color-Blob-Extraktor: Schon bekannt von dem Knopf links unten. ;-)

- Objekt-Extraktor: Das Herzstück des Projekts (deswegen hab ich eigentlich mal das ganze angefangen in dieser Dimension auszuarbeiten)

Wenn der Objekt-Extraktor RICHTIG(!) funktioniert können in einem beliebigen Bild,
mittels des angewendeten von mir entwickelten One-Pass-Verfahrens, Objekte vollautomatisch extrahiert werden.

ich krittel mal ein bischen herum.
zunächst die Test-Anwendung: ich finde, man bräuchte was, wo man vorher und nachher nebeneinander vergleichen kann, vlt sogar Tabpages, wo man verschiedene Filter-Ausgaben durchblättern kann.
Und das bei der Ausgabe angegeben ist, was man eingegeben hat, am liebsten was mit Abspeichern.
also ich jedenfalls hab nach 3 Sekunden vergessen, welches MenuItem ich geklickst hatte, und was in die EingabeMaske eingegeben.

Ich hab grad angemacht, ein Bild geladen, und dann mal bei den Filtern Binarisierung-BarCode geklickst, was immer das sein mag, darüber hoffte ich ja was zu erfahren.
Da geht ein Dialog auf, da soll ich einen Grenzwert eingeben, und checken (oder nicht), ob "nur diesen grenzwert".

Damit kann ich überhaupt nichts anfangen, was denn für ein Grenzwert?
habich 142 eingegeben.
Dann steht die Anwendung, und nach ca. 10s kommt ein schwarzweiß-Bild, bei dem scheinbar die Graustufen entfernt sind.
Vermutlich ist das die Binarisierung, dasses nurnoch schwarz-weiß gibt, aber warum Barcode? - na, so heißt es eben.

Nächster Test: Binarisierung-treshold MinMax - da muß man keinen Grenzwert angeben, aber die Anwendung steht für 20s.

Dafür gibts dann aber eine Ausgabe, bei der das Bild viel besser wieder zu erkennen ist - ein wirklich interessanter Filter. Blos wie gesagt - ich kann die Ausgabe nicht mit der Eingabe vergleichen, das ist schade.

Guck ich mal in den Code, da sehe ich gleich, warum das immer so lange steht: ist voll mit GetPixel und SetPixel. Wo ich denken täte, in etwas, was sich "LowLevel..." nennt, haben die nix verloren.
Man kann doch sicherlich alle Bildformate nach 24RGB umwandeln (bei Transparenz-Unterstützung 32ARGB), die Bitmap locken, und auf einem Array mit den Farbwerten arbeiten. Für 24RGB habich das mal selbst gemacht, und habe den Scan-Pointer in ein 2-dim ArbeitsArray kopiert, da kann man dann direkt mit x und y auf jeden Farbwert jedes Pixels zugreifen. Ich müsste mal probieren, ob mans nicht sogar in ein 3-dim Array bekommt, dann könnte man RGB quasi als Z-Achse auffassen.
Etwas, was danach aussieht, ist ja enthalten "UnsafeBitmap", nur wird es scheinbar nicht verwendet.

Als nächstes hab ich in die Convolutions geguckt, und scheint doch immer noch so, dass für jeden Filter eine eigene Klasse gebaut ist, dabei ist es immer derselbe Filter, nur mit verschieden beschickter 3*3-Matrix.
Sowas kann man doch variabel programmieren, dass im Button-Handler dann die Matrix beschickt wird, nicht für jeden filter eine extra-Klasse.

Einige Convolutions gehen dann auch wieder andere Wege, "SimpleConvolution" zB. wendet Bitmap-Locking an, und greift auf die Farbwerte direkt zu, aber eben ohne die "UnsafeBitmap" zu verwenden, wozu ist die denn nun eiglich da?

Oder im Ordner "Edges" guck ich den ersten an, da ist der Code komplett auskommentiert.
Und im 2. Edges-Filter, namens "Compass" findet sich wieder etwas, was sehr nach Convolution-Filter aussieht, allerdings sind es 688 Zeilen, die sich endlos wiederholen, und Get/SetPixel ist wieder dabei.
Zu Get/SetPixel habich mich schon geäußert, nun, solche "Compass"-Code-Wiederholungs-Wüsten sollte man aber auch unbedingt parametrisieren, also dass am Ende ein Algo mit geeigneten Parametern beschickt wird, anstatt für jede Variante den gleichen Algo re-implementieren.

In Corners.Moravec fund ich diese Minimum-Funktion:

C#-Code:

private int Min(int x, int y, int[,,] aSum)         {             int[] aInt = new int[8];             for (int i = 0; i < 8;i++ )             {                 aInt[i] = aSum[x,y,i];             }             Array.Sort(aInt);             return aInt[0];         }

Verstehe ich das richtig, dass alle 8 Werte in ein int-Array geschrieben werden, dieses sortiert, und dann das oberste Element zurückgegeben? - isnichdeinErnst, odr?

Das mit den BarCodes habichjetzt auch nochmal nachgeguckt

C#-Code:

public override void Execute(Bitmap _bitmap) {            Bitmap bitmap = _bitmap;            List<Color> aColor = new List<Color>();            int y = 0;            int x = 0;            int nCount = 0;            aColor.Add(bitmap.GetPixel(x, y));            aColor.Add(bitmap.GetPixel(x, y));            nCount++;            Color colorToSet = Color.Transparent;            for(y = 0; y < bitmap.Height; y++) {               for(x = 0; x < bitmap.Width; x++) {                  List<Color> aColorLine = new List<Color>();                  Color color = bitmap.GetPixel(x, y);                  aColor.Add(color);                  aColorLine.Add(color);                  Color colorPrev = aColor[nCount - 1];                  Color colorCurrent = aColor[nCount];                  Color colorAvg = ColorFunctions.AverageColor(aColorLine);                  int nRGBSum = ColorFunctions.RGBChannelSum(colorAvg);                  if(bOnlyThreshold) {                     if(nRGBSum == nThreshold) {                        colorToSet = Color.White;                        aColorLine.Clear();                     } else {                        colorToSet = Color.Black;                     }                  } else {                     if(nRGBSum > nThreshold) {                        colorToSet = Color.White;                        aColorLine.Clear();                     } else {                        colorToSet = Color.Black;                     }                  }                  bitmap.SetPixel(x, y, colorToSet);                  nCount++;               }            }         }

Interessant.
Da wird von den bisher durchlaufenen Pixeln ein Durchschnittspixel gebildet, und wenn die Summe der Farbwerte des Durchschnittspixels den Schwellwert (Threshold) überschreitet, wird weiß gesetzt, und die Liste der durchlaufenen Pixel gelöscht. (Ich hoffe, richtig verstanden zu haben, bischen Kommentation wäre nicht schlecht).
Welche Funktion hat aber die zweite Liste, "aColor"?

Forms.FormConvolution kann unnötigerweise im Designer nicht geöffnet werden. Das liegt am Aufruf von

C#-Code:

this.CenterToParent();

innerhalb von InitializeComponent(), wohl weil der Designer .CenterToParent() nicht ausführen kann.
Jedenfalls eine Verlegung des Aufrufes in den Konstruktor, nach InitializeComponent() schafft Abhilfe.

Was hat es mit diesem Interface auf sich?

C#-Code:

public interface ICommand     {         string Description { get; set; }         object Owner { get; set; }         void Run(object sender, EventArgs e);     }

Description: wird im ganzen Code nirgends gesetzt
Owner: desgleichen
Run: Was sollen die Argumente sender und e? Die werden zwar übergeben, aber nirgends dann auch verwendet - ich wüsste auch nicht, was ein filter mit einem toolstripMenuItem anfangen sollte, und e ist immer empty.

Auch die vielen Actions verstehe ich nicht. ist auch immer wieder ganz ähnlicher Code

C#-Code:

namespace ImageRecognition2.Action {     class ActionEdge : AbstractCommand     {         protected PictureBox m_PictureBox = null;         private short m_shType = -1;         public ActionEdge(PictureBox _pictureBox, short _shType)         {             m_PictureBox = _pictureBox;             m_shType = _shType;         }         public override void Run(object sender, EventArgs e)         {             FormParameter parameter = new FormParameter();             if (parameter.ShowDialog() == DialogResult.OK)             {                 Bitmap bitmap = (Bitmap)m_PictureBox.BackgroundImage;                 new EdgeDetectConvolution(m_shType, (byte)parameter.nValue).Execute(bitmap);             }         }     } }

C#-Code:

namespace ImageRecognition2.Action {     public class ActionDither : AbstractCommand     {         private PictureBox m_PictureBox = null;         public ActionDither(PictureBox _pictureBox)         {             m_PictureBox = _pictureBox;         }         public override void Run(object sender, EventArgs e)         {             Bitmap bitmap = (Bitmap)m_PictureBox.BackgroundImage;             BaseImageFilter filter = new Dither();             filter.Execute(bitmap);             Bitmap bitmapDithered = filter.Bitmap;             m_PictureBox.BackgroundImage = bitmapDithered;         }     } }

Ist zwar ähnlich, aber nicht gleich - warum nicht? beide Filter erben von einer gemeinsamen BasisFilterKlasse - trotzdem wird der EdgeFilter nur executet, beim Dither aber noch zusätzlich filter.Bitmap abgerufen.?.

Die Run-Methode hat dieselbe Signatur wie ein üblicher Eventhandler, und ich fänds glaub einfacher, den Code auch tatsächlich in einen echten Eventhandler reinzuschreiben, statt des in Form1 gegangenen Umwegs über eine Methode SetEventHandler

C#-Code:

public void SetEventHandler(ToolStripMenuItem _item, ICommand _icommand)         {             _item.Tag = _icommand;             _item.Enabled = true;             _item.Click += delegate(object sender, EventArgs e)             {                 ExecuteAction(_item.Tag,EventArgs.Empty);                 this.pictureBox1.Invalidate();                 Debug.WriteLine(_icommand.Description);             };         }

Also, ich mach Schluß für heut, hofflich habich dich nicht zu sehr geärgert.

Habe jetzt fleißig dran rumgeforscht, und (als erstes) gemerkt, dass das mit mehrdim Pointern nicht geht.
Und die superlangen Additionen eignen sich hervorragend als Optimierung. Elegant wäre gewesen, die Matrix in einer geschachtelten Schleife zu durchlaufen (wie im VBCode gezeigt), aber das ist 5 mal langsamer, als alle 9 Durchgänge in einer einzigen Addition aneinander zu hängen.
Ich find, Optimierungen sollte man kommentieren, weil der Code sieht üblicherweise grauenhaft und umständlich aus, und wenn man nicht weiß, dasses eine Optimierung ist, will man das natürlich gleich vereinfachen.
Ist auch ein Bug drin, nämlich vor und nach der X-Schleife musstenoch die Pointer um 3 hochsetzen, da du die Randpunkte ja nicht bearbeitest.
Der Bug führt zu falsch addressierten Pixeln, die sich im Filter-Ergebnis als Diagonale Linie zeigen, von obere rechte Ecke an.
Sieht man zB. beim Laplace-Filter.

Diese Features werden mit dem nächsten Upload veröffentlicht:

- Kuwahara Filter hinzugefügt (Rauschverringerungsfilter der Kanten erhält)
- Photoshopmodus-Filter (Farbig abwedeln, Multiplizieren, Weiches Licht, Hartes Licht, Umgekehrt Multiplizieren usw...)
- Bernsen Operator
- Lipschitz Filter
- Windowed Sinc Filter
- Non Maximum Suppression
- ChannelDifference Filter hinzugefügt (Unterschiede in Kanälen
- EntropyThreshold
- EnergyMap
- EntropyMap

- Lambda-Erweiterung LambdaPixel (Bitmap, x,y, Color, Rectangle Area)
Damit können auch auf ganz einfache Weise Flips u.ä. realisiert werden

- Bitmap 2 LINQ (Bitmap kann aufgrund Neighbouringsfunktionen als LINQ Objekt zurückgegeben werden)


Die neue Version gibt's diesmal erst, wenn alles andere auch durchgetestet sind.
Außerdem werden einige Filter wesentlich verschnellert werden.

- Einführung von Neighbouring zur eigenen Benutzung.
Durch ein GetNeighbour kann ein Window mit Größe s direkt erhalten werden:

Bsp. für die Neighbour von P für Window mit s = 3:
***
*P*
***

Bsp. für die Neighbours von P für Window mit s = 5:

*****
*****
**P**
*****
*****

Zitat:

Hast du schon (neben Grayscale) einen Brightness- und Contrastfilter implementiert? Das ist nämlich gerade genau das was ich suche. Wenn ja, arbeitet der schon mit Scan0 ? Das ganze muss so schnell wie möglich laufen damit es für mich ineteressant ist.

Die Filter befinden sich in dem Namespace LowLevelGraphics.Filter und heißen:

und heißen:

GrayScale,
Brightness,
Contrast

Alle benutzen Scan0.

Anwendungsbeispiele:

C#-Code:

new GrayScale().Execute(bitmap); new Brightness(10).Execute(bitmap); new Contrast(10).Execute(bitmap);

usw.