Forenbeiträge von dr4g0n76 Ingesamt 2.921 Beiträge
Kannst Du Deine Lösung posten, wie Du das gemacht hast? Würden andere bestimmt auch gerne sehen.
Existieren die Controls auch später wirklich auf der Form?
Oder bekommst Du im Direktwindow eine Exception?
InitializeComponent() ist nicht richtig oder Controls.Add() fehlt (wie schon vorgeschlagen) oder ähnliches...
wenn Du ein neues Element (neues Element derselben Art bzw. selben Typs) hinzufügst, siehst Du das dann?
Wenn ja, neues Element hinzufügen, nachsehen, warum dieses angezeigt wird, die anderen nicht.
Noch eine Idee:
Sind die Elemente noch im Vordergrund oder werden diese durch irgendwas anderes verdeckt?
Mal etwas mehr aus dem Context der bisher bestehenden Designer heraus,
hat jemand schon
betrachtet?
[ist ein VSIX Installer Projekt]
Ist das denn jetzt möglich, z.B. einen Druckertreiber in C#.NET zu entwickeln, habe eine Anfrage von jemandem bekommen.
laut Windows Driver Kit (WDK) 8.1 Preview Samples interpretier ich das so (und einigen anderen diversen Seiten, dass das jetzt geht).
[EDIT: Habe das allerdings nur ganz schnell überflogen und kann nicht beurteilen, ob das Beispielprojekt möglicherweise nur die Schnittstelle für den Treiber bereithält]
was ich immer etwas wundert: So eine Zusammenfassung ist ja eigentlich ein Standard-Problem, vor dem man immer wieder steht. Und natürlich gibt es dafür auch Standard-Algorithmen. Diese wurden ja auch genannt/verlinkt. Allerdings sind die - oder täusche ich mich - in den Papieren nur abstrakt beschrieben. Irgendwie scheinen konkrete Implementierungen Mangelware zu sein. Warum gibt es nicht - z.B. in
> - eine fertige Implementierung, der ich nur noch meine Liste mit den Daten gebe (und vielleicht noch ein paar optionale Parameter, wie z.B. der gewünschten Cluster-Anzahl oder des Mindestbreite der Lücken) und dann meine Cluster als Rückgabewert bekomme? Oder habe ich was übersehen?
Cluster Algorithm Using .NET Collections
K-Means Algorithm
Wie siehts damit aus? Hier kann die Distanz eingegeben werden.
Ausprobiert hab ich es selbst noch nicht.
So hatte ich das damals gelöst:
[gelöst] Richtextbox Inhalt ohne Control auf Canvas darstellen/zeichnen
Ja genau, es sind IMMER alle Punkte bekannt.
Diese wurden z.B. durch einen grafischen Filteralgorithmus ermittelt.
Benötigt wird es für die LowLevelGraphicsLibrary.
Es geht darum die Punktewolken in einzelne jeweils zusammengehörige Bereiche zu unterteilen.
Wenn sich z.B. im Punkte Bereich von x (0-100) und y (0-100) einzelne Punkte befinden und andere im Bereich von x (200-250) und y (200-250) dann sollen das zwei Punktewolken geben.
Da der Bereich nicht rechteck oder kreisförmig sein muss, könnte mit einem Convexhull-Algorithmus die Region gefunden werden.
Es geht darum in einem Bild Punktwolken zu finden, ich finde zwar allerhand Algorithmen, die etwas mit SCHON GEFUNDENEN Punktwolken anfangen, leider aber keinen der da ansetzt, wo es gilt die Punktwolken überhaupt erst zu finden.
Bisherige Ideen:
A)
1.) Punkt i (an Index k) nehmen
2.) 2. Punkt i (an Index k+1) nehmen
3.) Abstand zum jeweiligen Punkt mit Index n-1 messen,
solange kein Ausreisser -> aktuelle Punktwolke,
sobald Ausreisser -> neue Punktwolke.
Wieder bei 1.) allerdings mit nächstem Punkt durchgehen
B)
Punkte nehmen und bei jedem Punkt gucken, um welchen Punkt sich die Wolke bildet, quasi den Mittelpunkt der Wolke finden..., zu großer Ausreisser: Neue Wolke anlegen.
Weiß jemand wo es dazu einen State-Of-the-Art Algorithmus gibt?
Allerdings werden die Javascript Seiten, um die es geht doch nicht richtig gerendert.
d.h. die WebControl ActiveX Komponente läuft jetzt laut
whatbrowser.org
mit IE10. Trotzdem treten viele Fehler auf, die so einfach nicht auftreten, wenn die gleiche Seite direkt im IE10 aufgerufen wird.
Hab bisher nichts gefunden.
Versucht habe ich mir die Javascript Fehler anzusehen, um daraus einen Rückschluss ziehen zu können, ist mir bisher nicht gelungen.
weiss jemand dafür eine Lösung?
Jetzt gehts.
ok, der richtige key war bei mir anscheinend dieser:
HKEY_CURRENT_USER\Software\Microsoft\Internet Explorer\Main\FeatureControl\FEATURE_BROWSER_EMULATION
und doch nicht der für 64 Bit komischerweise...
[Getestet unter Windows 8]
Hab hier eine Lösung gefunden, leider funktioniert auch diese bei mir nicht:
Web Browser Control – Specifying the IE Version
habs auch mit dem Key für die 64-Bit version probiert.
Ich benutze die Internet-Explorer Active X Control in einem WinForm.
Manche Seiten werden nicht richtig gerendert. Jetzt habe ich in Internet Feature Controls (B..C) gelesen, dass man den Modus umstellen kann, durch Änderung der Registry-Einträge.
Scheint nicht zu funktionieren. Die entsprechenden Einträge sind wie gefordert umgestellt, aber es scheint alles immer noch im IE7 Modus gerendert zu werden.
Hatte jemand schon mal das gleiche Problem und dafür eine Lösung?
Wenn ich eine finde poste ich sie hier.
Folgende Aufgabe gilt es hier zu lösen, was anderes ist leider nicht erlaubt:
1.) Es gibt eine Webseite in der ein Diagramm mit Kendo-UI angezeigt wird.
2.) Außerdem einen Windowsdienst mit einem TCP-Serverthread der Zufallsdaten erzeugt, als XML.
Wenn auf 2.) ein Listener zugreift (soll mit JAVASCRIPT(!) geschehen),
soll dieser die XML Daten auslesen, um in 1.) neue Diagrammdaten hinzuzufügen.
Ist das überhaupt möglich mit reinem Javascript einen Socketlistener zu programmieren?
Link zu socket.io:
P.s.:
Habe zwar schon mehrere Beispiele wie jsocket.js/socket.io usw. gefunden, da scheinen aber immer bestimmte Komponenten zu fehlen, von denen ich nicht weiß, woher die sein sollen, z.B. ist der require-Befehl unbekannt.
P.p.s:
Ich probier jetzt mal npm zum Laufen zu bekommen, anscheinend kann man ja damit alles was für socket.io nötig ist, installieren?!
Vor einer Weile hatte es mich gepackt (3 Monate) und ich hab zusätzlich einen Blog über Persönlichkeitsentwicklung gestartet.
Hat jemand von euch etwas damit zu tun?
Wenn jemand möchte kann er sich gerne die Seite anschauen.
Die Seite ist werbefrei und einfach nur Informationen die ich zusammentrage, die anderen helfen sollen.
Um solche Fragen zu beantworten, gibt es jetzt einen Codegenerator.
Dieser ist auf die Properties, nicht auf den Constructor ausgerichtet.
So kann jeder sich selbst den Code erzeugen lassen, der die Aktion ausführt.
Benutze den Filter
Brightness
new Brightness(level).Execute(bitmap)
Danach das
Dispose
nicht vergessen.
Da gibt es umfangreiche Möglichkeiten. Es kommt immer darauf an, was man erreichen möchte. Ich denke Dir geht es wahrscheinlich darum, zu dunkle Bilder mehr oder weniger korrekt aufzuhellen und überbelichtete abzudunkeln.
Ich stelle zwei Beispiele online.
Spice up lighting conditions of your pic
Hinweis: Falls die Videos noch nicht komplett hochgeladen sein sollten, später noch mal auf der Seite vorbeigucken
Ich habe ein paar Videos auf
http://lowlevelgraphicslibrary.blogspot.de/
hinzugefügt, um zu zeigen. Was noch alles möglich ist.
Diesmal:
3 Tipps um Bilder künstlerisch zu verfremden.
Meiner Meinung nach ein sehr interessantes Buch über Gesprächsführung, um eine tiefe Verbindung zu jemandem aufzubauen und ausnahmsweise wurden hier zumindest einige Prinzipien richtig verstanden.
Trotzdem gilt auch hier:
Lesen und hinterfragen, nicht einfach annehmen, nicht einfach ablehnen. Ausprobieren.
Genau das wollte ich wissen, perfekt beantwortet.
Danke.
@Herbivore:
angenommen es geht um gleich geartete Properties: Benutzt Du denn diese Art von Vorgehensweise immer in Deinem Code?
Wenn ja, ist klar (s. z.B. aufgelistete Vorteile),
wenn nein, würde mich interessieren warum nicht.
Genau das entspricht auch meinen Vorstellungen, bis auf statistische Versuchsplanung, die hatte ich nicht auf meinem Radar.
Danke für die schnellen und - wie immer - kompetenten Antworten von euch.
Mein Projektleiter versteht das jedoch nicht und will jetzt, dass ich das von Hand mache. Bad Luck.
P.S.:
Sachliches Argumentieren half nicht, er versteht nicht den Unterschied zwischen den verschiedenen Berechnungsgrundlagen. Er versteht auch nicht den Unterschied zwischen Minima, Maxima und Durchschnittswerten und dass es sich lohnen könnte je nachdem verschieden anzunähern.
Ausgangssituation:
Ich habe ein Programm hier in der Firma.
_Intervallparameter_Es werden verschiedene Pattern getestet.
Ich darf ich in meiner Firma meine Bildverarbeitungskenntnisse nicht anwenden.
Also muss ich ein fehlerhaftes Programm benutzen, das jemand anders geschrieben hat.
Es hat sehr viele Intervallparameter. Die Tester wissen nicht, wie die richtigen Werte aussehen, um mit dem Programm RICHTIGE Ergebnisse zu erzielen.
Es gibt 23 Muster die geprüft werden und für jedes existieren exakt die gleichen Parameter.
_Richtige Parameter unbekannt, wie ermitteln?_Jetzt zur Situation:
Ich muss ein Programm über die Console aufrufen, dieses führt dann den Test durch, mein Vorschlag war die Parameter zu verändern. (Intervallgrenzen verengen/erweitern und Intervallverschiebung...)
wie finde ich das am schnellsten raus? (wenig Rechenzugriffe), da leider das Konsolenprogramm sehr langsam ist.
Threading geht nicht, weil eine Bilddatei 60 MB hat und mein Arbeitsrechner zu wenig Speicher.
Das hat geholfen. Vielen Dank Dir. 😃
Ich habe kleptomania von Structurise unter Windows 7 installiert, ohne Kompatibilitätsmodus. Habe dann festgestellt, dass es nicht mehr richtig funktioniert unter dieser Windows Version.
Also habe ich es wieder deinstalliert.
Was geblieben ist (s. Screenshot):
Manche Schriftarten sehen plötzlich so komisch aus, wie im Screenshot zu sehen.
Was könnte am System verstellt worden sein, dass die Schrift so komisch aussieht und vor allem: WIE BEKOMME ICH DAS WIEDER WEG?
Ich hab bisher nichts gefunden und alle erdenklichen Systemoptionen zur Schrift unter Windows 7 durchgeforstet.
Hallo Leute,
ich debugge von Windows 7 aus auf ein Smart Device Gerät auf dem Windows CE 5.0 läuft. Manchmal läuft alles wunderbar und dann bekomme ich wieder tagelang keine Verbindung.
Um debuggen zu können werden auf dem Smart Device per Telnet von Windows 7 aus cmclient2 und cmaccept gestartet. Manchmal funktioniert das ganze wunderbar,
dann eben wieder oft nicht.
Die Frage ist woran liegt das, dass es einmal geht dann wieder oft nicht?
Ich hab bisher alle MSDN Einträge und Google Forum durchforstet und alle Tipps ausprobiert und bin immer noch nicht weitergekommen.
Vielleicht hatte ja jemand schon das gleiche Problem und kann mir da weiterhelfen.
Ach ja:
Ich kann das Gerät natürlich anpingen, es läuft und ich komme auch jederzeit per Telnet drauf. Das ist kein Problem.
Ich kenne aber wohl immer noch nicht alle Bedingungen die erfüllt sein müssen.
Vielen Dank.
Wenn ich das richtig verstehe, dann wird der Rahmen ja durch zwei Rechtecke gebildet, mit dem gleichen Mittelpunkt. den Raum den beide einschließen, so dass der Rahmen von diesen erzeugt wird, den überprüfst Du einfach...
weiße Pixel zählen, andersfarbige Pixel zählen... bzw. die komplette Fläche des Rahmens in weiß sind 100%, dann brauchst Du nur ja beides entsprechend durcheinander teilen.
Vorausgesetzt ich hab es so verstanden wie Du meinst.
Hier eine Zwischen-Version (only Executables) also quasi ein Snapshot,
zum herumspielen und zu sehen, wie sich das ganze entwickelt hat.
EDIT: 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:
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
CTRL-F -> Filter ausführen
Menüpunkt Windows->Script: Script ausführen....
Feedback ist gerne gesehen.
Noch mal ein paar Videos hinzugefügt, u.a.:
Ich habe eine Matlab Funktion, die ich in C# umsetzen möchte, da ich leider nicht weiß, wie das Ergebnis aussehen muss, kann ich keine Rückschlüsse darauf schließen, wie der untere Code zu interpretieren ist. Es geht um den markierten Teil im Code.
Wie ist dieser zu verstehen?
Wenn bei Matlab irgendwo ein "." (Punkt) steht, bedeutet das soweit ich weiß, diese Operation wird für jeden einzelnen Wert durchgeführt.
Aber was bedeutet bei col_img(:,:,2) die Doppelpunkte? Ist das dann ein Vektor der alle rot Werte enthält?
Wenn ja, heißt das dann das bei Zeile 0047 alle Einzel-Werte der einzelnen Vektoren aufsummiert werden?
0044 r = col_img(:,:,1); // <== von hier
0045 g = col_img(:,:,2);
0046 b = col_img(:,:,3);
0047 int = r + g + b; // <== bis hier
0048
0049 cr = safeDivide(r,int) - hueParams.muR;
0050 cg = safeDivide(g,int) - hueParams.muG;
0051
0052 result = exp(-(cr.^2/hueParams.sigR^2/2 + ...
0053 cg.^2/hueParams.sigG^2/2 - ...
0054 cr.*cg * hueParams.rho/hueParams.sigR/hueParams.sigG));
Welche Definition gilt für eine
Center Surround Mask:
im Falle von einer SaliencyMap Generierung?
1.)
This mask is a center surround mask and is used to calculate the absolute difference between a central pixel and its eight surrounding neighbors. The greater the difference in color or gray level between an average of the neighboring pixels and the central pixel, the greater the result of the differencing calculation.
2.)center surround ”feature maps”
oder ist das auf Feature Maps bezogen im allgemeinen bei Pyramiden?
@MrSparkle:
Erklärung siehe dickgedruckter Text
The pruning algorithm is a technique used in digital image processing based on mathematical morphology.
It is used as a complement to the skeleton and thinning algorithms to remove unwanted parasitic components.
In this case 'parasitic' components refer to branches of a line which are not key to the overall shape of the line and should be removed. These components can often be created by edge detection algorithms or digitisation.The standard pruning algorithm will remove all branches shorter than a given number of points. The algorithm starts at the end points and recursively removes a given number (n) of points from each branch. After this step it will apply dilatation on the new end points with a (2N+1)(2N+1) structuring element of 1’s and will intersect the result with the original image. If a parasitic branch is shorter than four points and we run the algorithm with n = 4 the branch will be removed. The second step ensures that the main trunks of each line are not shortened by the procedure.
So nächste Frage:
hier frag ich mich, ob das obere wirklich der unteren Regelbeschreibung entspricht, wenn nicht, könnte es ja auch einfach sein, dass Verästelungen entfernt werden mit der Länge 60 (im oberen Beispiel) und es nicht 60 Iterationen sind...
Wie interpretiert ihr das?
Eine andere so genaue Beschreibung von "Pruning" hab ich bisher noch nicht gefunden.
EDIT: Das werde ich vorerst mal zurückstellen
Danke für die Antwort, irgendwie in diese Richtung wird es wohl gehen müssen...
Aber ich forsche weiter.
Ist manchmal ganz schön viel Arbeit sich die Informationen zusammenzutragen.
Vieles in der Bildbearbeitung ist einfach "unscharf" definiert... 😉
@Herbivore und Mr. Sparkle:
Zur Antwort:
Eigentlich wollte ich das ganze so wie in Halcon machen, da werden tatsächlich bei den Beispielen Dinge berechnet und dann angezeigt:
Sharpness = konkreter Wert...
usw.
habe aber leider bisher die Grundlage dafür nicht herausfinden können.
Wie wärs dann aber damit:
EDIT: Hinweis vorneweg:
**Die beiden GetProperties Befehle **
PropertyInfo[] aPropertyInfo = k.GetType().GetProperties();
aPropertyInfo[1].SetValue(k, numArray[0],null);
aPropertyInfo[0].SetValue(k, numArray[1],null);
funktionieren hier nur so weil die Properties "Min" und "Max" des Intervalls direkt hintereinander kommen. Normalerweise sollte man die Properties hier anhand des Namens identifizieren.
Hi,
ich habe jeweils eine Klasse IntInterval, FloatInterval, ByteInterval, DoubleInterval
Jetzt wollte ich die Properties dieser Klassen im PropertyGrid anzeigen und ändern können,
wenn ich
PropertyGrid.SelectObject = objectOfIntervalType;
funktionierte es wunderbar.
Aber wenn ich das von der Filterklasse gemacht habe, hat es nicht mehr funktioniert. Die Properties wurden zwar angezeigt (die Überladung der ToString-Methode in der Intervall-Klasse macht es möglich), aber ich konnte die Properties nicht editieren.
Hier meine Lösung Dazu.
Der Type Converter:
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Drawing;
using System.Windows.Forms;
using System.Reflection;
using System.ComponentModel;
using System.ComponentModel.Design.Serialization;
using System.Globalization;
using PropertyGridExtendedTypeTest.Types.Interval;
namespace PropertyGridExtendedTypeTest
{
/// <summary>
/// Double Interval Converter
/// </summary>
public class IntervalConverter<T, K> : TypeConverter where K : new()
{
/// <summary>
/// Can convert from...
/// </summary>
/// <param name="context"></param>
/// <param name="sourceType"></param>
/// <returns></returns>
public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType)
{
return ((sourceType == typeof(string)) || base.CanConvertFrom(context, sourceType));
}
/// <summary>
/// Determine if conversion is possible
/// </summary>
/// <param name="context"></param>
/// <param name="destinationType"></param>
/// <returns></returns>
public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType)
{
return ((destinationType == typeof(InstanceDescriptor)) || base.CanConvertTo(context, destinationType));
}
/// <summary>
/// Convert back
/// </summary>
/// <param name="context"></param>
/// <param name="culture"></param>
/// <param name="value"></param>
/// <returns></returns>
public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
{
string str = value as string;
if (str == null)
{
return base.ConvertFrom(context, culture, value);
}
string str2 = str.Trim();
if (str2.Length == 0)
{
return null;
}
if (culture == null)
{
culture = CultureInfo.CurrentCulture;
}
char ch = culture.TextInfo.ListSeparator[0];
string[] strArray = str2.Split(new char[] { ch });
T[] numArray = new T[strArray.Length];
TypeConverter converter = TypeDescriptor.GetConverter(typeof(double));
for (int i = 0; i < numArray.Length; i++)
{
numArray[i] = (T)converter.ConvertFromString(context, culture, strArray[i]);
}
if (numArray.Length != 2)
{
//throw new ArgumentException("TextParseFailedFormat", new object[] { str2, "Width,Height" });
}
K k = new K();
PropertyInfo[] aPropertyInfo = k.GetType().GetProperties();
aPropertyInfo[1].SetValue(k, numArray[0],null);
aPropertyInfo[0].SetValue(k, numArray[1],null);
//numArray[0], numArray[1]
return k;
}
public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType)
{
if (destinationType == null)
{
throw new ArgumentNullException("destinationType");
}
if (value is DoubleInterval)
{
if (destinationType == typeof(string))
{
DoubleInterval doubleInterval = (DoubleInterval)value;
if (culture == null)
{
culture = CultureInfo.CurrentCulture;
}
string separator = culture.TextInfo.ListSeparator + " ";
TypeConverter converter = TypeDescriptor.GetConverter(typeof(int));
string[] strArray = new string[2];
int num = 0;
strArray[num++] = converter.ConvertToString(context, culture, doubleInterval.Min);
strArray[num++] = converter.ConvertToString(context, culture, doubleInterval.Max);
return string.Join(separator, strArray);
}
if (destinationType == typeof(InstanceDescriptor))
{
Size size2 = (Size)value;
ConstructorInfo constructor = typeof(Size).GetConstructor(new Type[] { typeof(int), typeof(int) });
if (constructor != null)
{
return new InstanceDescriptor(constructor, new object[] { size2.Width, size2.Height });
}
}
}
return base.ConvertTo(context, culture, value, destinationType);
}
public override object CreateInstance(ITypeDescriptorContext context, IDictionary propertyValues)
{
if (propertyValues == null)
{
throw new ArgumentNullException("propertyValues");
}
object obj2 = propertyValues["Width"];
object obj3 = propertyValues["Height"];
if (((obj2 == null) || (obj3 == null)) || (!(obj2 is int) || !(obj3 is int)))
{
//throw new ArgumentException(SR.GetString("PropertyValueInvalidEntry"));
}
return new Size((int)obj2, (int)obj3);
}
public override bool GetCreateInstanceSupported(ITypeDescriptorContext context)
{
return true;
}
public override PropertyDescriptorCollection GetProperties(ITypeDescriptorContext context, object value, Attribute[] attributes)
{
return TypeDescriptor.GetProperties(typeof(Size), attributes).Sort(new string[] { "Width", "Height" });
}
public override bool GetPropertiesSupported(ITypeDescriptorContext context)
{
return true;
}
}
}
Und der Aufruf für eine der Intervallklassen als Beispiel:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Diagnostics;
using System.ComponentModel;
namespace PropertyGridExtendedTypeTest.Types.Interval
{
/// <summary>
/// The boundaries are momentarily included (>= ...)
/// If they should be excluded use ONLY greater or smaller sign
/// </summary>
[DebuggerDisplay("[{m_dMin}, {m_dMax}]")]
[DefaultPropertyAttribute("Interval")]
[TypeConverter(typeof(IntervalConverter<double, DoubleInterval>))]
public class DoubleInterval : IComparable<DoubleInterval>, ICloneable, ICustomTypeDescriptor
{
protected double m_dMin = 0.1f;
protected double m_dMax = 0.2f;
public DoubleInterval()
{
}
/// <summary>
/// constructor
/// </summary>
/// <param name="_dMin"></param>
/// <param name="_dMax"></param>
public DoubleInterval(double _dMin, double _dMax)
{
m_dMin = _dMin;
m_dMax = _dMax;
}
/// <summary>
/// Max value of this interval
/// </summary>
[DisplayName("Max")]
public double Max
{
get { return m_dMax; }
set { m_dMax = value; }
}
/// <summary>
/// Min value of this interval
/// </summary>
[DisplayName("Min")]
public double Min
{
get { return m_dMin; }
set { m_dMin = value; }
}
/// <summary>
/// Returns true, if the value is inside given interval
/// </summary>
/// <param name="_dValue"></param>
/// <returns></returns>
public bool Contains(double _dValue)
{
return _dValue >= m_dMin && _dValue <= m_dMax;
}
/// <summary>
/// Check if the current interval completely contains given interval
/// </summary>
/// <param name="_doubleInterval"></param>
/// <returns></returns>
public bool Contains(DoubleInterval _doubleInterval)
{
return m_dMin<=_doubleInterval.m_dMin && m_dMax>= _doubleInterval.m_dMax;
}
/// <summary>
/// This will check if an interval is overlapping, i.e. concrete:
/// True if one of the given boundaries is contained inside the interval.
/// The other boundary has to be outside the interval.
/// </summary>
/// <param name="_doubleInterval"></param>
/// <returns></returns>
public bool Intersects(DoubleInterval _doubleInterval)
{
return
(Contains(_doubleInterval.m_dMax) && !Contains(_doubleInterval.m_dMin))
|| (Contains(_doubleInterval.m_dMin) && !Contains(_doubleInterval.m_dMax))
;
}
/// <summary>
/// This returns the size of the interval.
/// Also negative sizes are allowed to show the direction.
/// Use Abs(Size) if direction is unimportant
/// </summary>
public double Size
{
get { return m_dMax - m_dMin; }
}
#region IComparable<DoubleInterval> Members
/// <summary>
/// An interval is bigger if its size is bigger
/// </summary>
/// <param name="other"></param>
/// <returns></returns>
public int CompareTo(DoubleInterval other)
{
return this.Size.CompareTo(other.Size);
}
#endregion
/// <summary>
/// Get interval as string in notation e.g. [0,1]
/// </summary>
/// <returns></returns>
public override string ToString()
{
return string.Format("[{0},{1}]", m_dMin, m_dMax);
}
#region ICloneable Members
/// <summary>
/// Use this to clone the interval
/// </summary>
/// <returns></returns>
public object Clone()
{
return new DoubleInterval(this.m_dMin, this.m_dMax);
}
#endregion
#region ICustomTypeDescriptor Members
/// <summary>
/// Returns a collection of custom attributes for this instance of a component.
/// </summary>
/// <returns>
/// An <see cref="T:System.ComponentModel.AttributeCollection"/> containing the attributes for this object.
/// </returns>
public AttributeCollection GetAttributes()
{
return TypeDescriptor.GetAttributes(this, true);
}
/// <summary>
/// Returns the class name of this instance of a component.
/// </summary>
/// <returns>
/// The class name of the object, or null if the class does not have a name.
/// </returns>
public string GetClassName()
{
return TypeDescriptor.GetClassName(this, true);
}
/// <summary>
/// Returns the name of this instance of a component.
/// </summary>
/// <returns>
/// The name of the object, or null if the object does not have a name.
/// </returns>
public string GetComponentName()
{
return TypeDescriptor.GetComponentName(this, true);
}
/// <summary>
/// Returns a type converter for this instance of a component.
/// </summary>
/// <returns>
/// A <see cref="T:System.ComponentModel.TypeConverter"/> that is the converter for this object, or null if there is no <see cref="T:System.ComponentModel.TypeConverter"/> for this object.
/// </returns>
public TypeConverter GetConverter()
{
throw new NotImplementedException();
}
/// <summary>
/// Returns the default event for this instance of a component.
/// </summary>
/// <returns>
/// An <see cref="T:System.ComponentModel.EventDescriptor"/> that represents the default event for this object, or null if this object does not have events.
/// </returns>
public EventDescriptor GetDefaultEvent()
{
return TypeDescriptor.GetDefaultEvent(this, true);
}
/// <summary>
/// Returns the default property for this instance of a component.
/// </summary>
/// <returns>
/// A <see cref="T:System.ComponentModel.PropertyDescriptor"/> that represents the default property for this object, or null if this object does not have properties.
/// </returns>
public PropertyDescriptor GetDefaultProperty()
{
return TypeDescriptor.GetDefaultProperty(this, true);
}
/// <summary>
/// Returns an editor of the specified type for this instance of a component.
/// </summary>
/// <param name="editorBaseType">A <see cref="T:System.Type"/> that represents the editor for this object.</param>
/// <returns>
/// An <see cref="T:System.Object"/> of the specified type that is the editor for this object, or null if the editor cannot be found.
/// </returns>
public object GetEditor(Type editorBaseType)
{
return TypeDescriptor.GetEditor(this, editorBaseType, true);
}
/// <summary>
/// Returns the events for this instance of a component using the specified attribute array as a filter.
/// </summary>
/// <param name="attributes">An array of type <see cref="T:System.Attribute"/> that is used as a filter.</param>
/// <returns>
/// An <see cref="T:System.ComponentModel.EventDescriptorCollection"/> that represents the filtered events for this component instance.
/// </returns>
public EventDescriptorCollection GetEvents(Attribute[] attributes)
{
return TypeDescriptor.GetEvents(this, attributes, true);
}
/// <summary>
/// Returns the events for this instance of a component.
/// </summary>
/// <returns>
/// An <see cref="T:System.ComponentModel.EventDescriptorCollection"/> that represents the events for this component instance.
/// </returns>
public EventDescriptorCollection GetEvents()
{
throw new NotImplementedException();
}
/// <summary>
/// Returns the properties for this instance of a component using the attribute array as a filter.
/// </summary>
/// <param name="attributes">An array of type <see cref="T:System.Attribute"/> that is used as a filter.</param>
/// <returns>
/// A <see cref="T:System.ComponentModel.PropertyDescriptorCollection"/> that represents the filtered properties for this component instance.
/// </returns>
public PropertyDescriptorCollection GetProperties(Attribute[] attributes)
{
throw new NotImplementedException();
}
/// <summary>
/// Returns the properties for this instance of a component.
/// </summary>
/// <returns>
/// A <see cref="T:System.ComponentModel.PropertyDescriptorCollection"/> that represents the properties for this component instance.
/// </returns>
public PropertyDescriptorCollection GetProperties()
{
return TypeDescriptor.GetProperties(this, true);
}
/// <summary>
/// Returns an object that contains the property described by the specified property descriptor.
/// </summary>
/// <param name="pd">A <see cref="T:System.ComponentModel.PropertyDescriptor"/> that represents the property whose owner is to be found.</param>
/// <returns>
/// An <see cref="T:System.Object"/> that represents the owner of the specified property.
/// </returns>
public object GetPropertyOwner(PropertyDescriptor pd)
{
return this;
}
#endregion
}
}
Ich hoffe das hilft euch weiter.
1.) Schärfe
Wie kann die Schärfe gemessen werden?
2.) Fokus
Ich denke mal anhand der Schärfe ist das evtl. auch möglich.
3.) Weichzeichnung
Wie kann die Weichzeichnung gemessen werden?
4.) Kontrast
Wie kann der Kontrast gemessen werden?
Es gibt verschiedene Verfahren, manche untersuchen die Kanten, andere betrachten Pixel an sich.
Aber was ist jeweils State of the Art?
Das konnte ich noch nicht herausfinden...
Wäre nett, wenn Du den anderen noch Deine Lösung beschreiben könntest...
hi stephh,
ich denke sinnvoll kann auch sein zu wissen, was ist denn Dein Ziel, was willst Du erreichen?
Soll am Ende ein Stereobild errechnet werden (Anaglyph 3d)?
Oder willst Du vielleicht sehen, ob Dein Bild unter verschiedenen Beleuchtungsbedingungen trotzdem noch Deinen Ansprüchen für die Weiterverarbeitung genügt?
Oder was ist dein Ziel?
Ich kann mir da viele Sachen vorstellen...
Wenn wir wissen was Du vorhast, können wir vielleicht besser helfen.
Vorneweg:
Würdet ihr das auch so machen, oder ein ganz anderes Verfahren wählen?
Ich möchte für die LowLevelGraphicsLibrary eine Funktion zur Verfügung stellen, die mit dem TextureCreator benutzt werden kann.
Wie die Überschrift schon sagt, sollen automatisch Seamless Textures erstellt werden können, aus einem Bild.
Ich schlage folgende Vorgehensweise vor:
Wenn P das Bild ist, wird automatisch p kopiert und viermal gegenüber gestellt:
P P
P P
Quasi wie Tiles in einem Spiel oder Landschaftseditor..., s. dazu auch angehängtes Bild....
Hier ist ja anhand der "Seams" noch klar erkennbar, wo die Grenzen des Ausgangsbilds sind.
Da das Bild jetzt so mit sich selbst 4 mal nebeneinander steht, kann ja quasi für jeden Rand, eine Überblendungsfunktion berechnet werden.
(Intern reicht es natürlich auch aus das Bild nur einmal zu haben und die gegenüberliegenden Seiten zu betrachten, jeweils links mit rechts und oben mit unten)
Also würde mir jetzt quasi eine Überblendungsfunktion reichen, die die Seams reduziert, zur Überprüfung würde es reichen, ob man noch Kanten findet.
Also nochmal:
Würdet ihr das auch so machen, oder ein ganz anderes Verfahren wählen?
P.S.: Für die Audiofreaks: Quasi wie ein Crossfade im Audiobereich... als Analogie...
Die richtige Methode ist hier eindeutig GraphicsPath u. ä. zu verwenden. Evtl. nur GraphicsPath.
Ich hab hier mal ausprobiert, wie der folgende Text zu übersetzen ist (direkt programmatisch, weil ich das für die Umsetzung für meine Library gebraucht habe)
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<svg
xmlns:dc="http://purl.org/dc/elements/1.1/"
xmlns:cc="http://web.resource.org/cc/"
xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
xmlns:svg="http://www.w3.org/2000/svg"
xmlns="http://www.w3.org/2000/svg"
xmlns:sodipodi="http://inkscape.sourceforge.net/DTD/sodipodi-0.dtd"
xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
version="1.1"
height="671.52"
width="753.12">
<metadata>
<rdf:RDF>
<cc:Work>
<dc:format>image/svg+xml</dc:format>
<dc:type rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
<dc:creator>
<cc:Agent>
<dc:title>MarianSigler, mariansigler@gmail.com</dc:title>
</cc:Agent>
</dc:creator>
<cc:license rdf:resource="http://web.resource.org/cc/PublicDomain" />
</cc:Work>
<cc:License rdf:about="http://web.resource.org/cc/PublicDomain">
<cc:permits rdf:resource="http://web.resource.org/cc/Reproduction" />
<cc:permits rdf:resource="http://web.resource.org/cc/Distribution" />
<cc:permits rdf:resource="http://web.resource.org/cc/DerivativeWorks" />
<cc:requires rdf:resource="http://web.resource.org/cc/ShareAlike" />
</cc:License>
</rdf:RDF>
</metadata>
<path style="fill:#FFFFFF; fill-rule:evenodd; stroke:#000000; stroke-width:2"
d="M 71.985614,631.52918 C 60.553114,631.52918 49.989054,625.43 44.272794,615.52918 C 38.556554,605.62833 38.556554,593.43 44.272794,583.52918 L 348.84719,55.99085 C 354.56345,46.09002 365.12751,39.990840 376.56,39.990840 C 387.99251,39.990840 398.55659,46.09002 404.27283,55.99085 L 708.84723,583.52918 C 714.56347,593.43 714.56347,605.62833 708.84723,615.52918 C 703.13097,625.42999 692.56691,631.52918 681.13441,631.52918 L 71.985614,631.52918 z " />
<path style="fill:#CC0000; fill-rule:evenodd; stroke:none"
d="M 71.985614,619.52918 C 64.840294,619.52918 58.237754,615.71720 54.665094,609.52918 C 51.092454,603.34114 51.092454,595.7172 54.665094,589.52918 L 359.23951,61.99086 C 362.81215,55.80282 369.41471,51.99084 376.56,51.99084 C 383.70533,51.990840 390.30787,55.802820 393.88053,61.990860 L 698.45493,589.52918 C 702.02757,595.71720 702.02757,603.34114 698.45493,609.52918 C 694.88227,615.7172 688.27973,619.52918 681.13441,619.52918 L 71.985614,619.52918 z M 141.2677,559.52918 L 376.56,151.99085 L 611.85233,559.52918 L 141.2677,559.52918 z " />
<path style="fill:black; stroke:none"
d="M 241.30092,493.56351 L 241.30092,454.05619 L 282.49629,490.27080 L 282.49629,359.67653 L 316.49739,359.67653 L 316.49739,490.27080 L 357.64860,454.05619 L 357.64860,493.56351 L 299.99084,549.83071 L 241.30092,493.56351 z" />
<path style="fill:black; stroke:none"
d="M 416.61975,533.42449 L 416.61975,401.62617 L 375.01943,437.67740 L 375.01943,397.80034 L 433.64084,343.52185 L 492.60266,397.80034 L 492.60266,437.67740 L 451.40733,401.62617 L 451.40733,533.61975 L 416.61975,533.42449 z " />
</svg>
Wichtig zum nachfolgenden Code,
wer svg umsetzen will sollte daran denken, dass im style die Fill-Farbe und im
Stroke eine andere Farbe normalerweise bedeuten:
e.Graphics.Fill und dann entsprechendes e.Graphics.Draw-Pendant benutzen.
Die Linienzüge sollten mit AddPolygon im entsprechenden GraphicsPath ergänzt werden, zumindest bis jetzt scheint das für alle SVG-Grafiken die ich ausprobiert habe zu stimmen.
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Linq;
using System.Text;
using System.Windows.Forms;
namespace ShowSVG
{
public partial class Form1 : Form
{
GraphicsPath graphicsPath = null;
public Form1()
{
InitializeComponent();
Panel svgPanel = new Panel();
this.Controls.Add(svgPanel);
svgPanel.Paint += new PaintEventHandler(svgPanel_Paint);
svgPanel.BackColor = Color.White;
svgPanel.Dock = DockStyle.Fill;
}
void svgPanel_Paint(object sender, PaintEventArgs e)
{
DrawZerothElement(e);
DrawFirstElement(e);
DrawSecondElement(e);
DrawThirdElement(e);
//SVGReader.Draw(e.Graphics, m_Bitmap);
}
private void DrawZerothElement(PaintEventArgs e)
{
graphicsPath = new GraphicsPath();
graphicsPath.StartFigure();
//"M 71.985614,631.52918
//C 60.553114,631.52918 49.989054,625.43 44.272794,615.52918
//C 38.556554,605.62833 38.556554,593.43 44.272794,583.52918
//L 348.84719,55.99085
graphicsPath.AddCurve(new Point[] { new Point(60, 631), new Point(49, 625), new Point(44, 615) });
graphicsPath.AddCurve(new Point[] { new Point(38, 605), new Point(38, 593), new Point(44, 583) });
graphicsPath.AddLine(44, 583, 348, 55);
//C 354.56345,46.09002 365.12751,39.990840 376.56,39.990840
//C 387.99251,39.990840 398.55659,46.09002 404.27283,55.99085
//L 708.84723,583.52918
graphicsPath.AddCurve(new Point[] { new Point(354, 46), new Point(365, 39), new Point(376, 39) });
graphicsPath.AddCurve(new Point[] { new Point(387, 39), new Point(398, 46), new Point(404, 55) });
graphicsPath.AddLine(404, 55, 708, 583);
//C 714.56347,593.43 714.56347,605.62833 708.84723,615.52918
//C 703.13097,625.42999 692.56691,631.52918 681.13441,631.52918
//L 71.985614,631.52918
//z " />
graphicsPath.AddCurve(new Point[] { new Point(714, 593), new Point(714, 605), new Point(708, 615) });
graphicsPath.AddCurve(new Point[] { new Point(703, 625), new Point(692, 631), new Point(681, 631) });
graphicsPath.AddLine(681, 631, 71, 631);
graphicsPath.CloseFigure();
e.Graphics.FillPath(Brushes.White, graphicsPath);
e.Graphics.DrawPath(new Pen(Color.Black, 2), graphicsPath);
graphicsPath.Dispose();
}
private void DrawFirstElement(PaintEventArgs e)
{
graphicsPath = new GraphicsPath();
graphicsPath.StartFigure();
//"M 71.985614,619.52918
graphicsPath.AddLine(71, 619, 64, 619);
//C 64.840294,619.52918 58.237754,615.71720 54.665094,609.52918
//C 51.092454,603.34114 51.092454,595.7172 54.665094,589.52918
//L 359.23951,61.99086
graphicsPath.AddCurve(new Point[] { new Point(64, 619), new Point(58, 615), new Point(54, 609) });
graphicsPath.AddCurve(new Point[] { new Point(51, 603), new Point(51, 595), new Point(54, 589) });
graphicsPath.AddLine(54, 589, 359, 61);
//C 362.81215,55.80282 369.41471,51.99084 376.56,51.99084
//C 383.70533,51.990840 390.30787,55.802820 393.88053,61.990860
//L 698.45493,589.52918
graphicsPath.AddCurve(new Point[] { new Point(362, 55), new Point(369, 51), new Point(376, 51) });
graphicsPath.AddCurve(new Point[] { new Point(383, 51), new Point(390, 55), new Point(393, 61) });
graphicsPath.AddLine(393, 61, 698, 589);
//C 702.02757,595.71720 702.02757,603.34114 698.45493,609.52918
//C 694.88227,615.7172 688.27973,619.52918 681.13441,619.52918
//L 71.985614,619.52918
graphicsPath.AddCurve(new Point[] { new Point(702, 595), new Point(702, 603), new Point(698, 609) });
graphicsPath.AddCurve(new Point[] { new Point(694, 615), new Point(688, 619), new Point(681, 619) });
graphicsPath.AddLine(681, 619, 71, 619);
//z
graphicsPath.CloseFigure();
//M 141.2677,559.52918
//L 376.56,151.99085
//L 611.85233,559.52918
//L 141.2677,559.52918
//z " />
graphicsPath.StartFigure();
graphicsPath.AddPolygon(new Point[] { new Point(141, 559), new Point(376, 151), new Point(611, 559), new Point(141, 559) });
graphicsPath.CloseFigure();
graphicsPath.CloseAllFigures();
e.Graphics.FillPath(Brushes.Red, graphicsPath);
e.Graphics.DrawPath(new Pen(Color.Black, 2), graphicsPath);
graphicsPath.Dispose();
}
private void DrawSecondElement(PaintEventArgs e)
{
//"M 241.30092,493.56351
//L 241.30092,454.05619
//L 282.49629,490.27080
//L 282.49629,359.67653
//L 316.49739,359.67653
//L 316.49739,490.27080
//L 357.64860,454.05619
//L 357.64860,493.56351
//L 299.99084,549.83071
//L 241.30092,493.56351 z" />
graphicsPath = new GraphicsPath();
graphicsPath.StartFigure();
graphicsPath.AddPolygon(new Point[]{
new Point(241,493),
new Point(241,454),
new Point(282,490),
new Point(282,359),
new Point(316,359),
new Point(316,490),
new Point(357, 454),
new Point(357,493),
new Point(299,549),
new Point(241,493)
});
graphicsPath.CloseFigure();
e.Graphics.FillPath(Brushes.Black, graphicsPath);
e.Graphics.DrawPath(Pens.Black, graphicsPath);
graphicsPath.Dispose();
}
private void DrawThirdElement(PaintEventArgs e)
{
//M 416.61975,533.42449
//L 416.61975,401.62617
//L 375.01943,437.67740
//L 375.01943,397.80034
//L 433.64084,343.52185
//L 492.60266,397.80034
//L 492.60266,437.67740
//L 451.40733,401.62617
//L 451.40733,533.61975
//L 416.61975,533.42449 z
graphicsPath = new GraphicsPath();
graphicsPath.StartFigure();
graphicsPath.AddPolygon(new Point[]{
new Point(416,401),
new Point(375,437),
new Point(375, 397),
new Point(433,343),
new Point(492,397),
new Point(492,437),
new Point(451, 401),
new Point(451,533),
new Point(416, 533)}
);
graphicsPath.CloseFigure();
e.Graphics.FillPath(Brushes.Black, graphicsPath);
e.Graphics.DrawPath(Pens.Black, graphicsPath);
}
}
}
Dieser Code erzeugt folgendes Bild:
Inzwischen ist das mit der LowLevelGraphicsLibrary möglich.
Hier gibt's ab jetzt Tutorials,
habe mich dazu entschlossen diese auf Englisch zu schreiben:
http://lowlevelgraphicslibrary.blogspot.com/
EDIT: Ich werde auch noch in den ersten Beitrag einfügen.
Da ich immer noch am entwickeln der LowLevelGraphicsLibrary bin und schon lange kein Update mehr gepostet habe (was vielleicht erst Ende diesen Jahres passieren wird, Updates können auf Anfrage verlangt werden...)
Bilder addieren bzw. arithmetische Operationen auf Bilder allgemein:
==================================================
Anscheinend ist auch hier nicht Definition = Definition
Nimmt man Halcon als Referenz dann gilt, wenn B1 Bild 2 ist, und B2 Bild 2,
dass die Grauwerte addiert werden,
Laut Matlab gilt:
Description
Z = imadd(X,Y) adds each element in array X with the corresponding element in array Y and returns the sum in the corresponding element of the output array Z. X and Y are real, nonsparse numeric arrays with the same size and class, or Y is a scalar double. Z has the same size and class as X, unless X is logical, in which case Z is double.
**_
wobei dass ja dann nichts mit dem Grauwert zu tun hat.
wenn es wirklich nicht eindeutig definiert ist,
werde ich alle Möglichkeiten integrieren die der PROCESSING_MODE der LowLevelGraphicsLibra5ry bietet und als Standard vorerst einmal Grau einstellen.[/b]_
EDIT:
wird das ganze so betrachtet:
X = uint8([ 255 0 75; 44 225 100]);
Y = uint8([ 50 50 50; 50 50 50 ]);
Z = imadd(X,Y)
Z =
255 50 125 94 255 150
dann ist es allerdings klar.
Kennt einer von euch eine LUA IDE mit der auch GUIs erstellt werden können, also visuell wie der Formular Editor im Visual Studio?
Hatte schon gedacht ich hätte was mit luaRAD gefunden, da gibt es aber keinen Download (mehr).
Wer hat da schon was gemacht?