Die Titlebar wird aus einem png gebildet, das muss unbedingt im Debug/Release Verzeichnis sein (grad2.png), sonst läufts nicht (File not found exception)
so ich häng jetzt einfach mal das rudimentäre Ding hier an als Attachment...
und nicht wundern wenn sich das Ding vielleicht seltsam verhält, wurde bisher nur auf meinem Rechner getestet und nur in einer Auflösung.
Habe das Ding mal so zusammengeschustert, damit man es hier überhaupt mal angucken kann. Zum Code bitte noch keinen Kommentar. Der muss noch gründlichst überarbeitet werden. Ausserdem ist das quasi immer noch eine pre-Alpha.
Die Titlebar wird aus einem png gebildet, das muss unbedingt im Debug/Release Verzeichnis sein (grad2.png), sonst läufts nicht (File not found exception)
Wenn man die OnDraw Methode überschreibt, kann man das Ding zu fast allem zwingen, wenn dann die Textboxen immer noch zu klein sein sollten, dann halt scrolling einbauen. geht alles.
Definier mal dein Problem bitte etwas genauer. Hast Du ein Darstellungsproblem an sich (Grafik?) oder geht es um die Textboxen aus denen die MultiColumn-ListBox besteht?
Und was willst du vergrößern, die ListBox, damit richtig angezeigt wird, oder die einzelnen Items in der ListBox? Tritt dabei sonst noch ein Problem auf, dass du lösen müßtest?
Das stimmt nicht immer ganz. Aber total falsch ist das auch nicht.
Nehmen wir an wir wollen eine DLL-Datei in C# benutzen, die wir zuvor in C++ geschrieben haben, weil sich das anbietet.
Jetzt müßte jeder der die Klasse benutzen wollte, wieder anfangen die Library-Definitionen usw. mit DllImport([]...) usw. zu definieren um die Funktionen zu benutzen, wenn er auch die DSL haben will.
WrapperKlasse::SendMidicode(string sCode) //Das wird nachher aufgerufen, wir müssen uns dann sonst um nix mehr kümmern.
{
SendMidiCode(sCode); //Das ist der DLL-Aufruf
}
Also wie man hier sieht, wird der Originalaufruf einfach in die Klasse eingebettet...
Wenn dann die Datentypen zusätzlich noch umgewandelt werden müssen, kriegt der Anwender davon gar nichts mit. :-)
Ist doch toll, oder?
Sorry habe etwas C++ und C#-Syntax hier vermischt, hoffe aber ist trotzdem verständlich.
Ich fände noch wichtig bei Controls zwischen Runtime und Designtime zu unterscheiden. Design-Time Controls sind dann diejenigen die man auch so im Editor einstellen kann, wie eben die Elemente die schon dabei sind und direkt im Design-Editor schon voreinstellen kann usw. z.B. wie ein button oder ein Label.
Lange nicht alle Menüpunkte funktionieren und das Rechteck das man mit der Maus aufziehen kann hat momentan auch keine Funktion... aber alles im entwickeln
Die wichtigsten Funktionen und Kürzel:
Fenster
CTLR-N -> neues Fenster aufmachen
STRG-ALT-C -> Fenster kaskadieren
STRG-ALT-H -> Horizontal anordnen
STRG-ALT-V -> Vertikal anordnen
New Window (open copy) -> vom aktuellen Fenster aus eine Kopie in einem neuen Fenster erstellen
New Window (last loaded) -> neues Fenster mit dem zuletzt geladenen Bild
Filter
CTRL-F -> Filter ausführen
Windows->Script:
Filter ausführen (oberer Execute-button)
hier auch Kanal auswählen, A,R,G,B, Mask (unterer Execute-button)
Oder direkt im Menü entsprechenden Filter auswählen
Lambdaausdrücke:
Oben im Filter eingeben oder aus Combobox auswählen
Menüpunkt Windows->Script: Script ausführen....
Bilder verknüpfen/Contextmenü oder Toolleiste:
Bilder im Fenster aus Childwindowliste auswählen...
EDIT: 17.01.2012
Hier gibt's ab jetzt kleine Tutorials usw. über diese Library:
EDIT: 22.04.2010
Als Dateianhang am Ende dieses Beitrags verfügbar.
Es wird immer mal wieder von mir ein Testprojekt hochgeladen, aber das wird nicht explizit hier jedesmal vermerkt.
EDIT: Prerelease Versionen gibt es immer - wenn vorhanden - hier:
Anmerkung: Ich behalte mir vor, die Datei umzubenennen oder herauszunehmen.
Der Code kann jetzt hier
heruntergeladen werden (s. Ende dieses Posts).
Achtung: Das Projekt ist noch nicht gegen Fehler getestet.
Zudem hat die Basis Klasse das Interface IFilter bekommen.
Dieses wird beinhalten:
- Steps (Quasi Pixel in X-Richtung und Y-Richtung überspringen)
- Rectangle (Ausschnitt auswählen, auf den der Filter angewendet werden kann)
- einige grundlegende Funktionen wie in der System.Drawing.Bitmaps-Klasse z.B. Height / Width, GetPixel / SetPixel
Was schon drin ist:
Einige Experimentelle Filter:
- Neue Filter, z.B. Background-Estimation
- Farben runden
- Segmentierungen
- Colorspaces, Umrechnungen von RGB in verschiedene Farbräume und zurück u.a.
YUV, YCbCr, HCL, HSV, XYZ, CIELUV, CIELAB usw.
- verschiedene Kantenfilter und ein neuer Konturfilter
- verschiedene rudimentäre Segmentierungsfilter.
- Viele statische RGB-Funktionen unter ColorFunctions wie z.B. Summe der Channels,
MaxChannel, MinChannel, Channels vertauschen per String z.B. mach BGG oder RBG oder BGR aus Original RGB, Channel-Ratio,
usw. alle diese Funktionen sind in ColorFunctions ausprogrammiert.
- BitmapFunctions-Klasse um ein Bild auf verschiedene Arten z.B. in einen Stream oder Byte-Array und wieder zurück umzuwandeln, zu resizen und zu rotieren.
Einen Filter benutzen:
Bitmap bitmap = (Bitmap)Image.FromFile("blub.jpg");
IFilter filter = new GrayScale();
filter.Execute(bitmap);
Die erste Zeile lädt das Bild,
die 2. Zeile instantiiert den Filter.
Dann wird der Filter angewendet
Zur Ausführung gibt es 3 Möglichkeiten:
1.) void Execute(bitmapSource);
Führt den Filter aus und bitmapSource enthält die neuen - veränderten - Informationen
2.) Bitmap ExecuteCloned(bitmapSource);
Führt den Filter geclont aus, d.h. bitmapSource wird nicht verändert, und die veränderte Bitmap wird zurückgegeben.
3.) void ExecuteMasked(bitmapSource, bitmapMask);
Führt den Filter aus und er wird nur an den Stellen angewendet in dem im Maskenbild weiße Pixel sind.
EDIT:
Als nächstes gibt es dann noch die Möglichkeiten:
4.) ExecuteChannelled
Für jeden Kanal kann angegegeben werden, ob das Ergebnis übernommen wird.
5.) ExecuteMaskedChannelled
Für jeden Kanal kann in Bezug auf die Maske angegeben werden, ob das Ergebnis übernommen wird.
EDIT: 4. und 5 sind jetzt implementiert.
Abkürzung des obigen Codes:
new GrayScale().Execute(bitmapSource); //Bild in Grau umwandeln.
Über ein UnsafeBitmap Objekt kann auf einfache und schnelle Weise auf ein Bitmap zugegriffen und es verändert werden:
UnsafeBitmap bitmap = new UnsafeBitmap(_bitmapSource);
//hier die Veränderungen durchführen
bitmap.Dispose(); //Und dann unbedingt Dispose aufrufen, um den Lock wieder freizugeben.
UnsafeBitmap bekommt als Eingang die originale Bitmap übergeben.
Dann wird intern alles durchgeführt um Unsafe auf die Bitmap zugreifen zu können.
Von außen sieht es aber aus, als würden wir ganz normal zugreifen.
List<Color> m_aColor = new List<Color>();
m_aColor.Add(Color.FromArgb(255,255,255));
UnsafeBitmap bitmap = new UnsafeBitmap(_bitmap);
for (int y = 0; y < bitmap.Height; y++)
{
for (int x = 0; x < bitmap.Width; x++)
{
Color color = bitmap.GetPixel(x, y);
if (!m_aColor.Contains(color))
{
bitmap.SetPixel(x, y, m_ColorToReplaceWith);
}
}
}
bitmap.Dispose();
ImageRecognition2.rar (3 MB, 42 mal heruntergeladen)
Hinweise:
Was tut sich aktuell?
EDIT: 15.03.2012
Aktuell geht es um alles fürs Vermessen und die Erkennung von Bildern, was eingebaut wird.
Im ersten Beispiel (Holz mit Loch) wurde eine Bitmap als Maske auf einen Dialog gelegt. Das läßt sich aber ohne weiteres auch mit den MDI-Fenstern machen.
Aber mal ehrlich: wer will ein MDI/SDI-Fenster mit Loch!?
Wenn du mit patterns designpatterns meinst, hier können keine selbst eingesetzt werden, da ich es direkt ins betriebssystem integriert habe und zwar mit c# boardmitteln. es werden also (noch) keine eigenen oder sonstige dlls verwendet.
Nur die events der Fenster wurden so überschrieben, dass die Skins dargestellt, die events aber trotzdem noch mit der Standard-Event-chain (eben wie gedacht) benutzt werden können.
Dazu wurde:
WndProc
PreprocessMessage
Rsize
Paint
OnPaintbackground
überschrieben.
In den Beispielen mit den MDI-Windows kam eine Klasse zum Einsatz die sich skinnedWindow nennt.
und nein, das links oben im eck jeweils ist kein Fehler, sondern nur ein Versuch zu gucken, ob man gleichzeitig Bilder und gezeichnetes verwenden kann.
Achtung: zum Tipp, Strings verwenden, enums können in C# tatsächlich in Strings umgewandelt werden, da auch enums objekte in C# sind.
Also z.B. wenn der Enum Farbe heißt:
enum Farbe
{
rot,
gruen,
blau
}
enum mycolor = chosenColor;
dann einfach chosenColor.toString() dahinter, das heißt, dann ergeben sich tatsächlich die Strings "rot", "gruen", "blau", je nachdem was im Objekt steckt. Ok?
Ich werds morgen online stellen, ok? erinnert mich bitte daran, falls bis dahin noch nichts geschehen ist. bin gerade auf arbeit und habe den code nur zuhause.
Falls es trotzdem nicht funktioniert hast du vielleicht den Namen der Font falsch angegeben, um das auszuschließen, weise an der Stelle einfach mal den FontDialog zu, nachdem auswählen (nach klick auf OK), weißt du dann das
Klar, geh in deinem Programm auf den mit InitializeComponent bezeichneten Code-Abschnitt, klapp ihn auf.
hier siehst du was alles festgelegt wird für deine Anwendung.
wenn du this. eintippst, siehst (fast) alles was Du für Deine Anweundung setzen kannst.
dann musst du folgendes machen:
this.Font = new Font("Arial",19);
und zwar am besten an der Stelle:
public MainForm()
{
// The InitializeComponent() call is required for Windows Forms designer support.
//
InitializeComponent();
this.Font = new Font("Arial",3); //hier font setzen
}
Also in Worten:
Im Konstruktor direkt nach dem Aufruf von InitializeComponent.
Hallo Leute, da es hier wohl bisher keinen Vorstellungsthread gibt, schreib ich mal hier rein.
Ich hab euch über Google entdeckt und erstmal die alten Threads durchgelesen und fands super was ihr euch überlegt habt.
Zu meiner Person: ich bin Programmierer von Beruf und mache das einfach für mein Leben gern. Kann bisher: Java, C#, C++, Perl, Assembler (68k und 8086), VB jeweils mit .NET-Varianten, Pascal, Delphi ziemlich gut.
Ansonsten komponiere ich schon seit einigen Jahren Musik und lese gerne (wenn ich überhaupt mal dazu komme. ;-)
Da ich viel Erfahrung auch mit .NET inzwischen habe, dachte ich, ich könnte vielleicht so eine Art Mentor sein, dann könntet ihr bei mir nachfragen, wenn ihr was nicht richtig wisst, wie es zu implementieren ist.
Übrigens habe ich angefangen Skins für C# zu schreiben, die mit jeder Anwendung funktionieren würden, das tolle ist, die Anwendungen sind nicht mal direkt darauf angewiesen die Klassen irgendwie zu integrieren. Das einzige was man machen MUSS ist:
Skin skin = new Skin();
das wars. Natürlich kann das aber auch alles individuell festgelegt werden.
Die Skins benötigen keinen Managed Code, das heißt alle Projekte sind mit dem normalen Standard-COmpiler-Schaltern immer noch laufbar.
Leider komme ich ausserhalb meines Berufes nicht allzuoft dazu etwas zu programmieren, deshalb habe ich gedacht ich kann anfangs einfach mal mit Rat und Tat beiseite stehen.
Übrigens, mit C# ist fast alles möglich, auch wenn man keine DLLs verwenden will. ;-)
Zuletzt habe ich versucht Hooks in Filedialogs zu implementieren (das ist dann so wie bei Photoshop wo man schon die Bildvorschau sieht bevor man geladen hat).
Läuft zu 90%...