function[] = fill(y,x) [i]hier kommt gleich der flood fill rein[/i]
%..andif the pixel under curPoint is a 1..
if(picWithAreas(i+1 , j) == 1)
%..itis added to the area..
area = vertcat(area,[i+1 , j]);
%..set zero..
picWithAreas(i+1 , j) = 0;
%..andset as initPoint for the next iteration.
fill(i+1 , j);
end
if(picWithAreas(i-1 , j) == 1)
%..itis added to the area..
area = vertcat(area,[i-1 , j]);
%..set zero..
picWithAreas(i-1 , j) = 0;
%..andset as initPoint for the next iteration.
fill(i-1 , j);
end
if(picWithAreas(i , j+1) == 1)
%..itis added to the area..
area = horzcat(area,[i , j+1]);
%..set zero..
picWithAreas(i , j+1) = 0;
%..andset as initPoint for the next iteration.
fill(i , j+1);
end
if(picWithAreas(i , j-1) == 1)
%..itis added to the area..
area = horzcat(area,[i , j-1]);
%..set zero..
picWithAreas(i , j-1) = 0;
%..andset as initPoint for the next iteration.
fill(i , j-1);
end
ich lese und probiere, sekunde. Bin auch noch etwas langsamer darin
Das was in [i} Tags steht kannst du schonmal löschen, da hab ich wiedermal versucht, was im Forum hier zu formatieren, ist im Code aber unbrauchbar
_________________
Nicht jeder der "Weswegen" fragt,
meint: "Wem gehört dieser Weg?".
Gut, also was mir schonmal zu deinem Code einfällt:
Das du in der dritten und vierten if-Abfrage das nicht mehr vertcat,
also vertikal konkateniert, sonder horzcat hast, finde ich unglaublich gut,
auch wenn es leider falsch ist. es zeugt aber zweifelsfrei davon, dass du dir Mühe gibst.
Auch das Prinzip, dass du bei beiden Koordinaten jeweils einmal +1 und einmal -1 gerechnet hast,
um die Nachbarn zu erwischen ist ein perfekter Ansatz.
Um uns beide zu belohnen (dich für die Mühe und mich... auch für die Mühe), kriegst du jetzt
meine komplette innere Funktion, und wir werden zusammen am korrekten Aufruf
dieser Arbeiten.
Das wichtigste beim Programmieren ist das Kommentieren, denn sonst fällt es allen, inkl. dir selbst,
unglaublich schwer, deinen Code zu lesen.
Hier meine innere Funktion, bevor du an den Aufruf gehst, verstehe sie vollkommen, indem
du die Kommentare im deutschen schreibst und den Code hier rein stellst. Bis gleich!
Code:
function[] = fill(y,x) % FILL using the flood_fill algorithm to iterate through all points of the % same area (4 directions), setting them to zero and adding the pixel to % area % Input : the coordinates of the initPoint in myMatrix % Output : no output, accesses myMatrix and area immidiate
sizePic = size(picWithAreas);
%If there is a Pixel under y..
if(sizePic(1) > y)
%..andif the pixel under curPoint is a 1..
if(picWithAreas(y+1 , x) == 1)
%..itis added to the area..
area = vertcat(area,[y+1 , x]);
%..set zero..
picWithAreas(y+1,x) = 0;
%..andset as initPoint for the next iteration.
fill(y+1,x);
end end % " ..left from.. " if(x > 1) if(picWithAreas(y, x-1) == 1) area = vertcat(area,[y , x-1]);
picWithAreas(y,x-1) = 0;
fill(y,x-1);
end end % " ..over.. " if(y > 1) if(picWithAreas(y-1, x) == 1) area = vertcat(area,[y-1 , x]);
picWithAreas(y-1,x) = 0;
fill(y-1,x);
end end % " ..right from.. " if(x < sizePic(2)) if(picWithAreas(y , x+1) == 1) area = vertcat(area,[y , x+1]);
picWithAreas(y,x+1) = 0;
fill(y,x+1);
end end
Hi, also hab das jetzt so gemacht.
Bin mir aber bei den folgenden Zeilen nicht so sicher,
das mit dem area=vertcat und pic with areas=0 verstehe ich nicht so ganz
Code:
area = vertcat(area,[y+1 , x]);
%..set zero..wenn es =0 ist dann wird es nicht beachtet bin
%mir aber nicht sicher
picWithAreas(y+1,x) = 0;
%..andset as initPoint for the next iteration.
fill(y+1,x);
% FILL using the flood_fill algorithm to iterate through all points of the % same area (4 directions), setting them to zero and adding the pixel to % area % Input : the coordinates of the initPoint in myMatrix % Output : no output, accesses myMatrix and area immidiate
sizePic = size(picWithAreas);
%Wenn Pixel über dem Wert y
if(sizePic(1) > y)
%Und wenn Pixel =1, also weiß ist dann
if(picWithAreas(y+1 , x) == 1)
%wird es zur Fläche dazugezählt
area = vertcat(area,[y+1 , x]);
%..set zero..wenn es =0 ist dann wird es nicht beachtet bin
%mir aber nicht sicher
picWithAreas(y+1,x) = 0;
%..andset as initPoint for the next iteration.
fill(y+1,x);
end end % " ..left from.. " if(x > 1) %Wenn der Wert x>1 ist dann
if(picWithAreas(y, x-1) == 1) %Wenn der Wert links von x=1 ist dann
area = vertcat(area,[y , x-1]);
picWithAreas(y,x-1) = 0; %set zero, wenn es =0 ist dann nicht beachten
fill(y,x-1); %Punkt für nächste suche nach der nächsten 1 festlegen
end end % " ..over.. " if(y > 1) %Wenn der Wert y>1 ist dann
if(picWithAreas(y-1, x) == 1) %Wenn der Wert unter y=1 ist dann
area = vertcat(area,[y-1 , x]);
picWithAreas(y-1,x) = 0; %set zero, wenn es =0 ist dann nicht beachten
fill(y-1,x); %Punkt für nächste suche nach der nächsten 1 festlegen
end end % " ..right from.. " if(x < sizePic(2)) %Wenn der Wert x>1 ist dann
if(picWithAreas(y , x+1) == 1) %Wenn der Wert rechts von x=1 ist dann
area = vertcat(area,[y , x+1]);
picWithAreas(y,x+1) = 0; %set zero, wenn es =0 ist dann nicht beachten
fill(y,x+1); %Punkt für nächste suche nach der nächsten 1 festlegen
end end
Ist n Anfang. Nein, also es wird null gesetzt, um damit zu zeigen, dass das Pixel schon "besucht" wurde. Sonst würde der Algorithmus ja unendlich lange hin und herspringen, so nach dem Motto:
Oh hey! Links von mir ist weiß. Sprung nach links. Oh hey! Rechts von mir ist weiß! Sprung nach rechts. Oh hey, links von mir ist weiß! etc
Um das zu verhindern, wird ein Pixel ABGESPEICHERT mit
und dann auf schwarz gesetzt (also quasi gelöscht).
Sooo... Das ist glaube ich verständlich. Weiter gehts:
Wenn du Kommentare übersetzt, dann alle. Auch die Beschreibung der Funktion ganz oben. Ich will, dass außer den Variablennamen oder Funktionsaufrufen kein Wort englisch mehr dort steht.
Dann ist jedem klar, dass geprüft wird, ob x größer als eins ist. Die Frage ist eher, warum das geprüft wird. Und das sollte man dann in die Kommentare schreiben!
Ich will es dir beantworten:
die Koordinaten deines Bildes reichen von (1,1) bis (sizePic(1), sizePic(2)),
alles was größer oder gleich der ersten koordinate und kleiner oder gleich der zweiten koordinate ist, liegt innerhalb deines bildes, alles andere außerhalb.
Das heißt, immer wenn du schaust, ob ein benachbartes Pixel weiß ist, schaust du vorher noch schnell, ob da überhaupt ein Pixel ist. Denn wenn dort keins ist, kannst du auch nicht die Farbe davon abrufen.
Gruß![/quote]
_________________
Nicht jeder der "Weswegen" fragt,
meint: "Wem gehört dieser Weg?".
% FILL using the flood_fill algorithm to iterate through all points of the % same area (4 directions), setting them to zero and adding the pixel to % area Benutzt den Flood_Fill algorithmus um alle Punkte der Selben % Fläche (in4-Richtungen, oben,unten,links,rechts) auf 0 zu setzen % und die Pixel zur Fläche dazu zu zählen % Input : the coordinates of the initPoint in myMatrix % Koordinaten des ersten Punktes mit >1 % Output : no output, accesses myMatrix and area immidiate ?
sizePic = size(picWithAreas);
%Wenn der Pixel innerhalb des Bildes liegt dann..
if(sizePic(1) > y)
%Und wenn Pixel =1, also weiß ist dann
if(picWithAreas(y+1 , x) == 1)
%wird es zur Fläche dazugezählt
area = vertcat(area,[y+1 , x]);
%Pixel auf 0 setzen, damit es nicht nochmals abgerufen
%wird-
picWithAreas(y+1,x) = 0;
%.Setzt den Punkt für den nächsten Aufruf
fill(y+1,x);
end end % " Nach Links" if(x > 1) %Wenn der Pixel innerhalb des Bildes liegt dann..
if(picWithAreas(y, x-1) == 1) %Wenn der Wert links von x=1 ist dann
area = vertcat(area,[y , x-1]);
picWithAreas(y,x-1) = 0; %Pixel auf 0 setzen, damit es nicht nochmals abgerufen
%wird-
fill(y,x-1); %.Setzt den Punkt für den nächsten Aufruf
end end % "Nach Oben" if(y > 1) %Wenn der Pixel innerhalb des Bildes liegt dann..
if(picWithAreas(y-1, x) == 1) %Wenn der Wert unter y=1 ist dann
area = vertcat(area,[y-1 , x]);
picWithAreas(y-1,x) = 0; %Pixel auf 0 setzen, damit es nicht nochmals abgerufen
%wird-
fill(y-1,x); %.Setzt den Punkt für den nächsten Aufruf
end end % "Nach Rechts " if(x < sizePic(2)) %Wenn der Pixel innerhalb des Bildes liegt dann..
if(picWithAreas(y , x+1) == 1) %Wenn der Wert rechts von x=1 ist dann
area = vertcat(area,[y , x+1]);
picWithAreas(y,x+1) = 0; %Pixel auf 0 setzen, damit es nicht nochmals abgerufen
%wird-
fill(y,x+1); %.Setzt den Punkt für den nächsten Aufruf
end end
Sehr gut, dann machen wir jetzt mal einen ersten Aufruf für die erste Fläche.
Da wo du dein Fragezeichen hinter output stehen hast, ist eine Stelle, die ich jetzt erkläre:
Die innere Funktion kann auf die Variablen der äußeren Funktion zugreifen. Die Variablen, auf die wir zugreifen heißen
"picWithAreas"
und
"area".
Die erste Variable steht dabei für das Bild, wo wir die Flächen nach und nach auf schwarz setzen. In der zweiten Variable speichern wir alle Koordinaten der einen Fläche.
Zur Initialisierung der Variablen:
picWithAreas ist bei mir der Input der äußeren Funktion, bei dir ist es ganz normal dein Bild.
area ist eine Matrix mit 2 Spalten (x und y Koordinate), und n Zeilen, wobei n für die Anzahl der zugehörigen Pixel zu eine Fläche gehört.
Code:
%The initial point is always the first part of the area..
area = [curPoint(1),curPoint(2)];
Der area können wir ja schonmal den zuerst gefundenen Punkt hinzufügen,
bei mir ist dieser curPoint. (steht für current Point, also der aktuell betrachtete Punkt).
Versuche mal, area jetzt anhand der inneren Funktion zu füllen, indem du sie aufrufst und deinen initial Punkt eingibst.
Gruß! Viel Erfolg, melde dich, wenn in area mehrere Werte stehen, oder wenn es nicht klappt. Danach sind nur noch ca. 3 Schritte zu tun.
_________________
Nicht jeder der "Weswegen" fragt,
meint: "Wem gehört dieser Weg?".
ich verstehe nicht ganz was du mit "füllen" meinst. Hab es jetzt mal so geschrieben aber verstehe nicht ganz wie du das meinst, sorry bin wie gesagt ein völliger Anfänger.
% FILL using the flood_fill algorithm to iterate through all points of the % same area (4 directions), setting them to zero and adding the pixel to % area Benutzt den Flood_Fill algorithmus um alle Punkte der Selben % Fläche (in4-Richtungen, oben,unten,links,rechts) auf 0 zu setzen % und die Pixel zur Fläche dazu zu zählen % Input : the coordinates of the initPoint in myMatrix % Koordinaten des ersten Punktes mit >1 % Output : no output, accesses myMatrix and area immidiate ?
%Der curPoint ist immer der Erste Teil der Fläche
area=[curPoint(1),curPoint(2)];
sizePic = size(picWithAreas);
%Wenn der Pixel innerhalb des Bildes liegt dann..
if(sizePic(1) > y)
%Und wenn Pixel =1, also weiß ist dann
if(picWithAreas(y+1 , x) == 1)
%wird es zur Fläche dazugezählt
area = vertcat(area,[y+1 , x]);
%Pixel auf 0 setzen, damit es nicht nochmals abgerufen
%wird-
picWithAreas(y+1,x) = 0;
%.Setzt den Punkt für den nächsten Aufruf
fill(y+1,x);
end end % " Nach Links" if(x > 1) %Wenn der Pixel innerhalb des Bildes liegt dann..
if(picWithAreas(y, x-1) == 1) %Wenn der Wert links von x=1 ist dann
area = vertcat(area,[y , x-1]);
picWithAreas(y,x-1) = 0; %Pixel auf 0 setzen, damit es nicht nochmals abgerufen
%wird-
fill(y,x-1); %.Setzt den Punkt für den nächsten Aufruf
end end % "Nach Oben" if(y > 1) %Wenn der Pixel innerhalb des Bildes liegt dann..
if(picWithAreas(y-1, x) == 1) %Wenn der Wert unter y=1 ist dann
area = vertcat(area,[y-1 , x]);
picWithAreas(y-1,x) = 0; %Pixel auf 0 setzen, damit es nicht nochmals abgerufen
%wird-
fill(y-1,x); %.Setzt den Punkt für den nächsten Aufruf
end end % "Nach Rechts " if(x < sizePic(2)) %Wenn der Pixel innerhalb des Bildes liegt dann..
if(picWithAreas(y , x+1) == 1) %Wenn der Wert rechts von x=1 ist dann
area = vertcat(area,[y , x+1]);
picWithAreas(y,x+1) = 0; %Pixel auf 0 setzen, damit es nicht nochmals abgerufen
%wird-
fill(y,x+1); %.Setzt den Punkt für den nächsten Aufruf
end end
Entschuldige die Verzögerung, ich bin nicht arbeitslos xD
Also pass auf:
Der Plan ist, dass in area alle Punkte einer Fläche drin stehen.
dh
area = [
xKoordinate erster Punkt, yKoordinate erster Punkt;
xKoordinate zweiter Punkt, yKoord. zweiter Punkt;
usw und so fort
]
Am Anfang ist Area NICHT = 0 (wie in deinem Code),
sondern gleich des ersten initialpunktes (den wir erst mit find bestimmt haben)
JETZT NOCHMAL WAS ANDERES:
vertcat macht, dass du an eine Matrix eine Zeile dranhängst.
Also an der Stelle, wo wir
schreiben, hängen wir an die Matrix area, die im ersten Schritt nur eine Koordinate hat, eine weitere Zeile, also eine weitere Koordinate dran.
Hier der Aufruf:
Code:
%Find the first one..
[row, col] = find(picWithAreas);
%..andset it as initial point for flood_filling.
curPoint = [ row(1),col(1)];
%The initial point is always the first part of the area..
area = [curPoint(1),curPoint(2)];
%..so lets set it to zero and then..
picWithAreas(curPoint(1),curPoint(2)) = 0;
%..rush through all other points by the inner function 'fill'.
fill(curPoint(1),curPoint(2));
%Some of the points are visited multiple times, so they have to be
%cleaned -> every point is left unique after that.
area = unique(area,'first','rows');
%All pixels in the current area are in this matrix now, so..
%..we can take the size(the number of points), and..
sizeArea = size(area,1);
%..thesum of all x and all y coordinates.
sumArea = sum(area,1);
Hi, ich komme dort nicht wirklich weiter, muss ich nicht erst die ganzen if befehle ablaufen lassen?
hab das jetzt so gemacht aber es kommt nicht wirklich was dabei raus, leider! Langsam verwirrt mich der Code
% FILL using the flood_fill algorithm to iterate through all points of the % same area (4 directions), setting them to zero and adding the pixel to % area Benutzt den Flood_Fill algorithmus um alle Punkte der Selben % Fläche (in4-Richtungen, oben,unten,links,rechts) auf 0 zu setzen % und die Pixel zur Fläche dazu zu zählen % Input : the coordinates of the initPoint in myMatrix % Koordinaten des ersten Punktes mit >1 % Output : no output, accesses myMatrix and area immidiate ?
%Der curPoint ist immer der Erste Teil der Fläche
area = [curPoint(1),curPoint(2)];
%..CurPoint wird auf 0 gesetzt
picWithAreas(curPoint(1),curPoint(2)) = 0;
%..läuft durch alle Punkte in der Fläche durch.
fill(curPoint(1),curPoint(2));
%Mehr Punkte werden öfter durchlaufen, deswegen müssen diese
%"gesäubert" werden -> jeder punkt bleibt danach einfach zurück
area = unique(area,'first','rows');
%Alle Pixel der Fläche sind jetzt in einer Matrix
%Die größe wird durch die Anzah lder Pixel bestimmt
sizeArea = size(area,1) ;
%Die Summe aller x und y Koordinaten
sumArea = sum(area,1);
sizePic = size(picWithAreas);
%Wenn der Pixel innerhalb des Bildes liegt dann..
if(sizePic(1) > y)
%Und wenn Pixel =1, also weiß ist dann
if(picWithAreas(y+1 , x) == 1)
%wird es zur Fläche dazugezählt
area = vertcat(area,[y+1 , x]);
%Pixel auf 0 setzen, damit es nicht nochmals abgerufen
%wird-
picWithAreas(y+1,x) = 0;
%.Setzt den Punkt für den nächsten Aufruf
fill(y+1,x);
end end % " Nach Links" if(x > 1) %Wenn der Pixel innerhalb des Bildes liegt dann..
if(picWithAreas(y, x-1) == 1) %Wenn der Wert links von x=1 ist dann
area = vertcat(area,[y , x-1]);
picWithAreas(y,x-1) = 0; %Pixel auf 0 setzen, damit es nicht nochmals abgerufen
%wird-
fill(y,x-1); %.Setzt den Punkt für den nächsten Aufruf
end end % "Nach Oben" if(y > 1) %Wenn der Pixel innerhalb des Bildes liegt dann..
if(picWithAreas(y-1, x) == 1) %Wenn der Wert unter y=1 ist dann
area = vertcat(area,[y-1 , x]);
picWithAreas(y-1,x) = 0; %Pixel auf 0 setzen, damit es nicht nochmals abgerufen
%wird-
fill(y-1,x); %.Setzt den Punkt für den nächsten Aufruf
end end % "Nach Rechts " if(x < sizePic(2)) %Wenn der Pixel innerhalb des Bildes liegt dann..
if(picWithAreas(y , x+1) == 1) %Wenn der Wert rechts von x=1 ist dann
area = vertcat(area,[y , x+1]);
picWithAreas(y,x+1) = 0; %Pixel auf 0 setzen, damit es nicht nochmals abgerufen
%wird-
fill(y,x+1); %.Setzt den Punkt für den nächsten Aufruf
end end
Ist eine innere Funktion.
Immer wenn du sie aufrufst, und für y,x eine 1 eingibst, dann schreibt sie in area alle weiteren Punkte die rein, die zur gleichen Fläche gehören.
DAS HEIßT:
Die function fill ist vollständig so, wie ich es in einem meine vorherigen posts als "fertig" deklariert habe. Weitere änderungen, wie das hineinkopieren dessen, was ich danach postete ist unsinnig.
Du schreibst jetzt den "Aufruf" wie ich ihn in einem meiner neueren Posts geschrieben habe, ÜBER (nicht in, über(!)) die function fill.
Dann sollte der Rest wie von alleine laufen, für die erste Fläche.
Noch ein Tipp:
Wenn du hinter eine Variable das Semikolon wegnimmst, dann wird sie bei der Ausführung auf der Konsole ausgegeben. Da ich mittlerweile weder Lust noch Nerven, plus selbst Zeug zu tun habe, und noch kein Danke gehört habe, werde ich mich evtl nicht mehr in diesem Forum melden.
Den Rest schaffst du, wenn du es wirklich willst, locker selbst. Denn die erste Fläche habe ich dir jetzt im Prinzip zu mind. 85% vorgegeben. Für alle anderen Flächen musst du dann, wenn es für die erste Fläche klappt, nur noch eine while-Schleife setzen, mit der Bedingung, dass pixWithAreas nicht schon leer ist. Das lässt sich mit einer sinnvollen Kombination aus find und length basteln, frag einfach mal Tante Google.
_________________
Nicht jeder der "Weswegen" fragt,
meint: "Wem gehört dieser Weg?".
Hi, tut mir leid bin ziemlich angenervt von diesem Zeug. Wenn du bis jetzt kein Dank gehört hast tut es mir leid. Ich bin dir wirklich sehr sehr dankbar, dass du dir die Zeit nimmst/genommen hast. Jeder Post hat mir ein Stück weitergeholfen ist echt super.
Die erste Fläche wollte ich mir jetzt so ausgeben lassen, jedoch zeigt er im Workspace für size Area und sumArea folgendes an was mir komisch erscheint. Hoffe du nimmst dir nochmals die Zeit.
[i,j]=find(picWithAreas)
curPoint = [ i(1),j(1)]
%Der curPoint ist immer der Erste Teil der Fläche
area = [curPoint(1),curPoint(2)];
%..CurPoint wird auf 0 gesetzt
picWithAreas(curPoint(1),curPoint(2)) = 0;
%..läuft durch alle Punkte in der Fläche durch.
fill(curPoint(1),curPoint(2));
%Mehr Punkte werden öfter durchlaufen, deswegen müssen diese
%"gesäubert" werden -> jeder punkt bleibt danach einfach zurück
area = unique(area,'first','rows');
%Alle Pixel der Fläche sind jetzt in einer Matrix
%Die größe wird durch die Anzah lder Pixel bestimmt
sizeArea = size(area,1)
%Die Summe aller x und y Koordinaten
sumArea = sum(area,1)
% FILL using the flood_fill algorithm to iterate through all points of the % same area (4 directions), setting them to zero and adding the pixel to % area Benutzt den Flood_Fill algorithmus um alle Punkte der Selben % Fläche (in4-Richtungen, oben,unten,links,rechts) auf 0 zu setzen % und die Pixel zur Fläche dazu zu zählen % Input : the coordinates of the initPoint in myMatrix % Koordinaten des ersten Punktes mit >1 % Output : no output, accesses myMatrix and area immidiate ?
sizePic = size(picWithAreas);
%Wenn der Pixel innerhalb des Bildes liegt dann..
if(sizePic(1) > i)
%Und wenn Pixel =1, also weiß ist dann
if(picWithAreas(i+1 , j) == 1)
%wird es zur Fläche dazugezählt
area = vertcat(area,[i+1 , j]);
%Pixel auf 0 setzen, damit es nicht nochmals abgerufen
%wird-
picWithAreas(i+1,j) = 0;
%.Setzt den Punkt für den nächsten Aufruf
fill(i+1,j);
end end % " Nach Links" if(j > 1) %Wenn der Pixel innerhalb des Bildes liegt dann..
if(picWithAreas(i, j-1) == 1) %Wenn der Wert links von x=1 ist dann
area = vertcat(area,[i , j-1]);
picWithAreas(i,j-1) = 0; %Pixel auf 0 setzen, damit es nicht nochmals abgerufen
%wird-
fill(i,j-1); %.Setzt den Punkt für den nächsten Aufruf
end end % "Nach Oben" if(i > 1) %Wenn der Pixel innerhalb des Bildes liegt dann..
if(picWithAreas(i-1, j) == 1) %Wenn der Wert unter y=1 ist dann
area = vertcat(area,[i-1 , j]);
picWithAreas(i-1,j) = 0; %Pixel auf 0 setzen, damit es nicht nochmals abgerufen
%wird-
fill(i-1,j); %.Setzt den Punkt für den nächsten Aufruf
end end % "Nach Rechts " if(j < sizePic(2)) %Wenn der Pixel innerhalb des Bildes liegt dann..
if(picWithAreas(i , j+1) == 1) %Wenn der Wert rechts von x=1 ist dann
area = vertcat(area,[i , j+1]);
picWithAreas(i,j+1) = 0; %Pixel auf 0 setzen, damit es nicht nochmals abgerufen
%wird-
fill(i,j+1); %.Setzt den Punkt für den nächsten Aufruf
end end
Ich habe jetzt nicht nochmal dein Bild rausgekramt, aber was spricht denn dagegen, das deine Werte stimmen?
sizeArea sagt einfach nur, dass deine Areas aus drei Pixeln besteht (Prüfe selbst.) SumArea war nur für meine aufgabenstellung relevant, für dich ist es egal und du kannst die Zeile löschen.
_________________
Nicht jeder der "Weswegen" fragt,
meint: "Wem gehört dieser Weg?".
Du kannst Beiträge in dieses Forum schreiben. Du kannst auf Beiträge in diesem Forum antworten. Du kannst deine Beiträge in diesem Forum nicht bearbeiten. Du kannst deine Beiträge in diesem Forum nicht löschen. Du kannst an Umfragen in diesem Forum nicht mitmachen. Du kannst Dateien in diesem Forum posten Du kannst Dateien in diesem Forum herunterladen
MATLAB, Simulink, Stateflow, Handle Graphics, Real-Time Workshop, SimBiology, SimHydraulics, SimEvents, and xPC TargetBox are registered trademarks and The MathWorks, the L-shaped membrane logo, and Embedded MATLAB are trademarks of The MathWorks, Inc.
RSS