示例#1
0
 // ------ eine Region einfärben ------
 private void colorRegion(ClusterRegion region, Bgr color)
 {
     foreach (KeyValuePair<Cluster, int> c in region.clusters)
     {
         Dictionary<Pixel, int> pixels = c.Key.pixels;
         foreach (KeyValuePair<Pixel, int> p in pixels)
         {
             imageSuperpixels.Data[p.Key.vector.y, p.Key.vector.x, 0] = Convert.ToByte(color.Blue);
             imageSuperpixels.Data[p.Key.vector.y, p.Key.vector.x, 1] = Convert.ToByte(color.Green);
             imageSuperpixels.Data[p.Key.vector.y, p.Key.vector.x, 2] = Convert.ToByte(color.Red);
         }
     }
 }
示例#2
0
        // =============== Ähnliche benachbarte Cluster zusammenfassen ===============
        private void createRegions()
        {
            Console.WriteLine("Create Regions");

            int colorDistanceLimit = 1;

            bool clustersAddedToRegion;

            // aktuell zu prüfender Cluster
            Cluster currentCluster;

            // Liste mit aktuell zu prüfenden Nachbarn
            Dictionary<Cluster, int> currentNeighbours = new Dictionary<Cluster, int>();

            // Liste mit neu zu prüfenden Nachbarn
            Dictionary<Cluster, int> newNeighbours = new Dictionary<Cluster, int>();

            int regionNr = -1;

            int i = 0;
            // alle Cluster durchlaufen
            do
            {
                // aktuellen Cluster setzen
                currentCluster = clusters[i];
                //Console.WriteLine("=========================");
                //Console.WriteLine("aktueller Cluster Nr: " + i);

                // wenn aktueller Cluster noch nicht bearbeitet wurde
                if (!currentCluster.scanned)
                {
                    //Console.WriteLine("- neue Cluster-Region für Cluster Nr: " + i);

                    // Cluster bearbeiten
                    currentCluster.scanned = true;

                    // neue Cluster-Region erstellen
                    regionNr++;
                    ClusterRegion currentRegion = new ClusterRegion(regionNr);

                    //aktuellen Cluster zur neu angelegten Region hinzufügen
                    currentRegion.clusters.Add(currentCluster, 0);
                    currentCluster.regionNr = regionNr;

                    // Anfangsnachbarn festlegen
                    currentNeighbours = currentCluster.neighbours;

                    // Cluster-Region weiter scannen, bis keine ähnlichen Nachbarn mehr gefunden werden
                    do
                    {
                        //Console.WriteLine("-- " + currentNeighbours.Count + " neue Cluster untersuchen");

                        // noch keine Cluster zur Cluster-Region hinzugefügt
                        clustersAddedToRegion = false;

                        // aktuell zu prüfende Nachbarcluster auf Ähnlichkeit überprüfen
                        foreach (KeyValuePair<Cluster, int> cluster in currentNeighbours)
                        {
                            //Console.WriteLine("--- check Cluster");

                            // wenn Nachbarcluster noch keiner ClusterRegion zugeordnet wurde und ähnlich zur aktuellen Cluster-Region ist
                            if (!cluster.Key.scanned && currentCluster.colorDistance(cluster.Key) < colorDistanceLimit)
                            {
                                // Console.WriteLine("---- Ähnlichkeit festgestellt");

                                // Cluster markieren
                                cluster.Key.scanned = true;

                                // Cluster zur Cluster-Region hinzufügen
                                currentRegion.clusters.Add(cluster.Key, 0);
                                cluster.Key.regionNr = regionNr;

                                //Console.WriteLine("regionNr = " + regionNr);

                                // erster Cluster übernimmt Pixel des zweiten
                                //currentCluster.pixels = currentCluster.pixels.Concat(neighbour.Key.pixels).ToDictionary(x => x.Key, x => x.Value);

                                // noch nicht markierte Nachbarn des Clusters in Liste merken
                                foreach (KeyValuePair<Cluster, int> n in cluster.Key.neighbours)
                                {
                                    //Console.WriteLine("----- Nachbar von gefundenem Nachbar angucken");
                                    if (!newNeighbours.Contains(n) && !n.Key.scanned)
                                    {
                                        //Console.WriteLine("------ Zu neuer Nachbar-Liste hinzufügen");
                                        newNeighbours.Add(n.Key, 0);
                                    }
                                }
                                // aktuellen Cluster aus der Nachbarliste löschen
                                //newNeighbours.Remove(currentCluster);

                                // zweiten Cluster löschen
                                //clusterList.Remove(neighbour.Key);

                                // Farbe neu berechnen
                                //currentCluster.calcColor();

                                // Farbe der Region neu berechnen
                                /*
                                Bgr newColor = currentRegion.calcColor();
                                // neue Farben allen enthaltenen Clustern zuweisen
                                foreach (KeyValuePair<Cluster, int> c in currentRegion.clusters)
                                {
                                    c.Key.color = newColor;
                                }
                                */

                                // neue Cluster wurden verbunden
                                clustersAddedToRegion = true;

                            }
                        }

                        // wenn Cluster zur aktuellen Region hinzugefügt wurden
                        if (clustersAddedToRegion)
                        {
                            // neue Nachbarn für nächsten Durchlauf
                            currentNeighbours.Clear();
                            currentNeighbours = currentNeighbours.Concat(newNeighbours).ToDictionary(x => x.Key, x => x.Value);

                            // zu bearbeitende Nachbarn löschen
                            newNeighbours.Clear();

                            // neue Nachbarn speichern
                            currentCluster.neighbours = newNeighbours;

                            // Liste mit neuen Nachbarn löschen
                            newNeighbours.Clear();

                            //Console.WriteLine("--- Ähnliche Nachbarn wurden gefunden");
                        }

                    }
                    //bis keine ähnlichen Nachbar-Cluster mehr gefunden werden
                    while (clustersAddedToRegion);

                    // Farbe der Region neu berechnen
                    currentRegion.calcColor();

                    // Region der Liste hinzufügen
                    regionList.Add(currentRegion);

                    //Console.WriteLine("- Größe Cluster-Region: " + currentRegion.clusters.Count());
                    i++;
                }
                else
                {
                    //Console.WriteLine("- überspringen");
                    // wenn Cluster schon markiert, weiter mit nächstem Cluster
                    i++;
                }

            }
            // bis letzter Cluster erreicht wurde
            while (i < clusterList.Count());
        }