WICHTIG: Der Betrieb von goMatlab.de wird privat finanziert fortgesetzt. - Mehr Infos...

Mein MATLAB Forum - goMatlab.de

Mein MATLAB Forum

 
Gast > Registrieren       Autologin?   

Partner:




Forum
      Option
[Erweitert]
  • Diese Seite per Mail weiterempfehlen
     


Gehe zu:  
Neues Thema eröffnen Neue Antwort erstellen

Probleme bei Implementierung einer Binarisierung

 

Signal_Neuling
Forum-Anfänger

Forum-Anfänger


Beiträge: 15
Anmeldedatum: 11.05.20
Wohnort: ---
Version: R2019b
     Beitrag Verfasst am: 01.05.2022, 14:47     Titel: Probleme bei Implementierung einer Binarisierung
  Antworten mit Zitat      
Hi @all,

ich versuche einen Algorithmus zu einer Binarisierung zu implementieren.
Der besagte Bin.Algo. wird in dem angehängten PDF beschrieben und habe noch das Bsp.Bild von Seite 3 mit angehängt.


Als erstes Lese ich das Bild ein und erzeuge gleich ein Kanten Bild.
Der empfohlene Schwellwert liegt im Paper für den Canny Algo. bei 0.001, jedoch sahen damit meine Ergebnisse nicht aus wie auf S.3 Fig.2 (b) , daher habe ich den Schwellwert auf 3/128 angepasst und habe damit vorerst "ähnliches" Ergebnis erzielt
Code:

test_img = imread('16_09.jpg');
test_img = rgb2gray(test_img);

figure; image(test_img); colormap(gray);
axis off; title('Original Bild');

test_img_kanten = uint8( edge(test_img, 'Canny', 3/128) )*255;
figure; image(test_img_kanten); colormap(gray);
axis off; title('Canny Kanten-Bild');
 


Danach wird wie beschrieben das Varianzbild mit einer 5x5 Maske erzeugt was auch wie im Paper ausschaut.
Code:


% Generiere Varianz Bild :   Varianz Bild = Varianz(Grauwert Bild)
% Empfohlene Maskengröße  5x5
window_size = 5;
varianzBild = im_varFilt(test_img, window_size);
varianzBild = imcomplement(uint8(varianzBild));
figure; image(varianzBild); colormap(gray); axis off; title('Varianz-Bild');

 


Hier die im_varFilt Funktion.
Code:

% Image varFilt
function o_img = im_varFilt(i_img, window_size)

 I = double(i_img);
%Define the window size
sz = window_size;
mn=floor(sz/2);
%Preallocate the matrix
o_img = zeros(size(I));
%Pad the matrix with zeros
I = padarray(I,[mn mn]);

for i=1:size(I,1)-mn*2
for j=1:size(I,2)-mn*2
tmp = I(i:i+(sz-1),j:j+(sz-1));
mu = mean(tmp(:));
        tmp2 = mean(tmp(:).^2);
o_img(i,j)=tmp2 - mu.^2;
end
end
 


Dann soll das Varianz Bild auch mit dem Canny Algo. gefiltert werden um so die Grenzlinien / Außenkonturen eines Schriftzugs zu erhalten.

Jedoch egal wie ich es mache, erhalte ich innerhalb meines Schriftzugs zusätzliche Linien und Details... (Vergleich: S.3 Fig2 a)

Code:

% % Falten der x und y -Masken mit Varianz-Bild.
% mask_x = [-1, 0, 1; -2, 0, 2; -1, 0, 1];
% mask_y = [1, 2, 1; 0, 0, 0; -1, -2, -1];
mask_x = [-1 0 0 0 1]';  
mask_y = [-1 0 0 0 1];
xVar = conv2(varianzBild, mask_x, 'same');
yVar = conv2(varianzBild, mask_y, 'same');

%Summe der Quadrate der Varianz-Kanten-Bilder radizieren
varKanten = sqrt( (xVar.^2) + (yVar.^2) );
figure; image(varKanten); colormap(gray);
axis off; title('Kanten von Varianz-Bild ohne BIN.');

thresh = mean(varKanten(:));
test_Kanten = uint8( varKanten >= 9*thresh )*255;
figure; image(test_Kanten); colormap(gray);
axis off; title('Kanten von Varianz-Bild mit BIN.');

% varianz_kanten = edge(varianzBild, 'Canny');
% figure; imagesc(varianz_kanten); colormap(gray); axis off; title('Varianz-Kanten-Bild');
 



Soweit so gut..
Nun sollen aber die nicht geschlossenen Konturen der Schriftzüge geschlossen werden was in Step 4 auf S.2 beschrieben wird.
Jedoch bin ich ratlos wie ich das genau implementieren soll und zwar wird in Step 4.2 ein OR verknüpfung des Grauwert-Kanten-Bilds und des Varianz-Kanten-Bilds erzeugt.
In dem Ergebnisbild sollen nun alle connected Components, die im Varianz-Kanten-Bild eine Kontur berühren, sozusagen in eine Matrix extrahiert werden.

Dazu habe ich mir die Befehlde bwconncomp, bwtraceboundary und bwboundaries angeschaut und damit etwas rumgespielt.

Code:

OR_Kanten = uint8(uint8(varKanten) | test_img_kanten)*255;
figure; image(OR_Kanten); colormap(gray); axis off; title('ver-Odertes-Kanten-Bild');

CC_4_OR = bwconncomp(OR_Kanten, 4);
CC_8_OR = bwconncomp(OR_Kanten, 8);

labeled_OR4 = labelmatrix(CC_4_OR); figure; colormap(gray); image(labeled_OR4);axis off; title('OR 4-connected components ');
labeled_OR8 = labelmatrix(CC_8_OR); figure; colormap(gray); image(labeled_OR8);axis off;title('OR 8-connected components');

 


Aber habe keine Ahnung wie ich weiter verfahren soll. In den images der Conected Components sind zwar zusammenhängende Gebiete aber diese haben im geringsten etwas mit dem Schriftzug zu tun. Wie ich diese dann letztlich noch in eine neue Matrix extrahieren soll weiß ich garnicht. Confused Question

Über Tipps und Tricks würde ich mich sehr freuen.

Danke im Voraus und euch einen schönen Sonntag. Smile
Bis dahin.

____An_improved_scene_text_and_document_image_binarization_scheme.pdf
 Beschreibung:
In diesem PDF wird der Algorithmus beschrieben.

Download
 Dateiname:  ____An_improved_scene_text_and_document_image_binarization_scheme.pdf
 Dateigröße:  4.98 MB
 Heruntergeladen:  188 mal
16_09.jpg
 Beschreibung:
Bsp.Bild

Download
 Dateiname:  16_09.jpg
 Dateigröße:  327.77 KB
 Heruntergeladen:  167 mal
Private Nachricht senden Benutzer-Profile anzeigen


Signal_Neuling
Themenstarter

Forum-Anfänger

Forum-Anfänger


Beiträge: 15
Anmeldedatum: 11.05.20
Wohnort: ---
Version: R2019b
     Beitrag Verfasst am: 11.05.2022, 09:45     Titel:
  Antworten mit Zitat      
Hi an alle.
Ich bin etwas weitergekommen und mein Output sieht schon nicht ganz so schlecht aus Confused Smile

Hier erstmal mein Code.

Code:

% Test Bild einlesen.
% test_img = imread('tools.bmp');
test_img = imread('16_09.jpg');
test_img = rgb2gray(test_img);

figure; image(test_img); colormap(gray);
axis off; title('Original Bild');

% pasc_mask_1d = 1/16*[1 4 6 4 1];
% pasc_mask = conv2(pasc_mask_1d, pasc_mask_1d');
gauss_mask = fspecial('gaussian', 5, 1);

test_img_glatt = conv2(test_img, gauss_mask, 'same');
figure; image(test_img_glatt); colormap(gray); axis off; title('Original Bild geglättet mit Gauß', 'Interpreter', 'none');

EG2 = uint8( edge(test_img_glatt, 'Canny',  0.1 ) )*255;    % 23/512   13/512  29/512  25/512       0.005
figure; image(EG2); colormap(gray); axis off; title('Canny Kanten-Bild   EG2');


% Generiere Varianz Bild :   Varianz Bild = Varianz(Grauwert Bild)
% Empfohlene Maskengröße  5x5
window_size = 5;
varianzBild = im_varFilt(test_img, window_size);
varianzBild = imcomplement(uint8(varianzBild));     % .*0.75
figure; image(varianzBild); colormap(gray); axis off; title('Varianz-Bild');

varianzBild_glatt = conv2(varianzBild, gauss_mask, 'same');
figure; image(varianzBild_glatt); colormap(gray); axis off; title('Varianz-Bild geglättet');

EG1 = uint8(edge(varianzBild_glatt, 'canny', 11/32 ));   % 5/32       1/32
figure; imagesc(EG1); colormap(gray); axis off; title('Canny Kanten-Var.-Bild     EG1');


%%

L = bitor(EG1, EG2);
figure; image(uint8(L)*255); colormap(gray); axis off; title('ver-Odertes-Kanten-Bild');

CC_OR = bwconncomp(L, 8);
labeled_OR = labelmatrix(CC_OR);
% figure; colormap(gray); image(uint8(labeled_OR8)*255) ;axis off; title('OR 8-connected components');

BW_Labeled = imbinarize(uint8(labeled_OR)*255);
[OR_conn_comps, ccs] = bwboundaries(BW_Labeled, 8, 'noholes');
% figure; image(uint8(ccs)*255); colormap(gray); axis off; title('OR 8: connected components in Grauwert-Kanten-Bild verODERt');

EG2_map = zeros(size(test_img));
for i = 1:length(OR_conn_comps)
    for j = 1:length(OR_conn_comps{i})
        EG2_map ( OR_conn_comps{i}(j), OR_conn_comps{i}(j + length(OR_conn_comps{i})) ) = uint8(255);
    end
end

BW_varKanten = imbinarize(EG1);
[EG1_conn_comps, ccs] = bwboundaries(BW_varKanten, 8, 'noholes');
% figure; image(uint8(ccs)*255); colormap(gray); ;axis off; title('connected components in Varianz-Kanten-Bild');

EG1_map = zeros(size(test_img));
for i = 1:length(EG1_conn_comps)
    for j = 1:length(EG1_conn_comps{i})
        EG1_map ( EG1_conn_comps{i}(j), EG1_conn_comps{i}(j + length(EG1_conn_comps{i})) ) = uint8(255);
    end
end

figure; image(EG1_map); colormap(gray); axis off; title('vCC´s');
figure; image(EG2_map); colormap(gray); axis off; title('gCC´s');

and_map = bitand(EG1_map, EG2_map);
figure; image(uint8(and_map)*255); colormap(gray);  axis off; title('EG1 & EG2');

% Moroph. Bridging
SK = bwmorph(and_map,'bridge');
figure; image(uint8(SK)*255); colormap(gray); axis off; title('boundary_map mit morph. bridging', 'Interpreter', 'none');

%%
% Vergleiche Connected Components
conn_comps = compCC(EG1_conn_comps, OR_conn_comps);

% Setze alle PixelKoordinaten von conn_comps in F1 = 255
F1 = zeros(size(test_img));
for i = 1:length(conn_comps)
    for j = 1:length(conn_comps{i})
        F1(conn_comps{i}(j), conn_comps{i}(j + length(conn_comps{i})) ) = 255;
    end
end

figure; image(F1); colormap(gray); axis off; title('F1', 'Interpreter', 'none');

done_image = calc_directional_thresholds(test_img, (F1./255), [3 3]);
figure; image(uint8(done_image)*255); colormap(gray); axis off; title('F1 binarisiert', 'Interpreter', 'none');
 



im_varFilt.m
Code:

function o_img = im_varFilt(i_img, window_size)

 I = double(i_img);
mn=floor(window_size/2);

% Bildspeicher anlegen
o_img = zeros(size(I));

% Zero padding
I = padarray(I,[mn mn]);

for i=1:size(I,1)-mn*2
    for j=1:size(I,2)-mn*2
        % initialisiere Tmp mit allen Elementen die unter aktuellen
        % Maskenpositionen sind !
        tmp = I(i:i+(window_size-1),j:j+(window_size-1));
       
        % berechne Mittelwert d. Elemente und Mittelwert d. Quadrate d. Elemente unter d. Maske
        mu = mean(tmp(:));
        tmp2 = mean(tmp(:).^2);
       
        o_img(i,j)=tmp2 - mu.^2;
    end
end
 


compCC.m
Code:

function conn_comps = compCC(var_conn_comps, gray_conn_comps)

% Vergleiche gray_conn_comps mit var_conn_comps.
% Jede gray_conn_comp die eine var_conn_comp berührt ( eigentlich angrenzt  !!) -> in conn_comps speichern !
conn_comps = [];
strike = 0;

for i = 1:length(gray_conn_comps)
    for j = 1:length(var_conn_comps)
       
        if ~isempty(intersect(gray_conn_comps{i}, var_conn_comps{j}, 'rows'))
            conn_comps = [conn_comps; { gray_conn_comps{i} }];
            strike = 1;
        end
        if strike == 1
             strike = 0;
             break;
        end

    end
end
 


Je nachdem wieviel zusammenhängende Gebiete in den Teilbildern gefunden werden, brauch die Funktion compCC ihre Zeit. Bei mir manchmal mehr als 30 Minuten.


calc_directional_thresholds.m
Code:

function done_img = calc_directional_thresholds(org_gray_img, boundary_map, window_size)

row_bin_img = zeros(size(org_gray_img));
col_bin_img = zeros(size(org_gray_img));

pix_koord_le_bound = 0;
pix_koord_ri_bound = 0;
pix_koord_hi_bound = 0;
pix_koord_lo_bound = 0;
last_pix_koord_ri_bound = 0;
last_pix_koord_lo_bound = 0;

strike_le_bound = 0;
strike_ri_bound = 0;
strike_hi_bound = 0;
strike_lo_bound = 0;
strike_no_bound = 0;

controllVar_copyBound = 0;

sz = floor(window_size/2);
gray_img = padarray(org_gray_img, sz);

for i = 1:size(org_gray_img, 2)         % i = laufvariable f. Spalten
    for j = 1:size(org_gray_img, 1)     % j = laufvariable f. Zeilen
        % Spaltenweise über Bild und Grenzen in Zeilen suchen.
        cur_pix_val = boundary_map(j, i);
       
        % Wenn: controllVar_copyBound == 1
        % d.H.: übernehme alte untere Grenze als neue obere
        if controllVar_copyBound == 1
            pix_koord_hi_bound = last_pix_koord_lo_bound;
            controllVar_copyBound = 0;
            strike_hi_bound = 1;
        end
           
       
        % Wenn: Pixel == true und strike_le_bound == 0
        % d.H.: Zeile N Spalte M -> Grenze gefunden
        if cur_pix_val == true && strike_hi_bound == 0
            pix_koord_hi_bound = [j+1 i+1];
            strike_hi_bound = 1;
           
        % Wenn: Pixel == false und strike_le_bound == 1 und
        % strike_no_bound == 0
        % d.H.: Zeile N Spalte M linke Grenze gefunden (mit evtl.
        % vertikaler Richtung). Ende gefunden
        elseif cur_pix_val == false && strike_hi_bound == 1 && strike_no_bound == 0
            strike_no_bound = 1;
           
        % Wenn: Pixel == true und strike_le_bound == 1 und
        % strike_no_bound == 1
        % d.H.: Zeile N Spalte M rechte Grenze gefunden
        elseif cur_pix_val == true && strike_hi_bound == 1 && strike_no_bound == 1
            pix_koord_lo_bound = [j+1 i+1];
            strike_lo_bound = 1;
            strike_no_bound = 0;
           
        elseif j == size(org_gray_img, 1) && strike_hi_bound == 1
            pix_koord_lo_bound = [j+1 i+1];
            strike_lo_bound = 1;
            strike_no_bound = 0;
        end
         
        % Wenn: strike_le_bound == 1 und strike_ri_bound == 1
        % d.H.: linke und rechte GrenzKoordinaten gefunden -> starte
        % Berechnungen und binarisiere Bild Zeilen und zusätzlich Teilweise
        if strike_hi_bound == 1 && strike_lo_bound == 1
               
            cur_sum = my_sum_fun(gray_img, window_size, pix_koord_hi_bound);
            cur_sum = cur_sum + my_sum_fun(gray_img, window_size, pix_koord_lo_bound);  
            cur_mean = cur_sum / 18;
               
        % Indizierung auf Originalbild anpassen.
            m = pix_koord_hi_bound(1, 1) - 1;
            n = pix_koord_hi_bound(1, 2) - 1;
            p = pix_koord_lo_bound(1, 1) - 1;
            q = pix_koord_lo_bound(1, 2) - 1;
           
            row_start = m;  row_end = p;  col_start = n;  col_end = q;
            col_bin_img(row_start:row_end, col_start:col_end) = org_gray_img(row_start:row_end, col_start:col_end) > cur_mean;
           
        % KontrollVariablen zurücksetzen
            if j < size(org_gray_img, 1)
                last_pix_koord_lo_bound = pix_koord_lo_bound;
                controllVar_copyBound = 1;
            elseif j >= size(org_gray_img, 1)
                last_pix_koord_lo_bound = 0;
                controllVar_copyBound = 0;
            end
           
            strike_hi_bound = 0;
            strike_lo_bound = 0;
            pix_koord_hi_bound = 0;
            pix_koord_lo_bound = 0;
        end  
    end
   
    pix_koord_hi_bound = 0;
    pix_koord_lo_bound = 0;
    last_pix_koord_ri_bound = 0;

    strike_hi_bound = 0;
    strike_lo_bound = 0;
    strike_no_bound = 0;
    controllVar_copyBound = 0;
end


for j = 1:size(org_gray_img, 1)         % j = laufvariable f. Zeilen
    for i = 1:size(org_gray_img, 2)     % i = laufvariable f. Spalten
        % Zeilenweise über Bild und Grenzen in Zeilen suchen.
        cur_pix_val = boundary_map(j, i);
       
        % Wenn: controllVar_copyBound == 1
        % d.H.: übernehme alte rechte Grenze als neue linke
        if controllVar_copyBound == 1
            pix_koord_le_bound = last_pix_koord_ri_bound;
            controllVar_copyBound = 0;
            strike_le_bound = 1;
        end
       
        % Wenn: Pixel == true und strike_le_bound == 0
        % d.H.: Zeile N Spalte M -> Grenze gefunden
        if cur_pix_val == true && strike_le_bound == 0
            pix_koord_le_bound = [j+1 i+1];
            strike_le_bound = 1;
           
        % Wenn: Pixel == false und strike_le_bound == 1 und
        % strike_no_bound == 0
        % d.H.: Zeile N Spalte M linke Grenze gefunden (mit evtl. horizontaler
        % Richtung). Ende gefunden
        elseif cur_pix_val == false && strike_le_bound == 1 && strike_no_bound == 0
            strike_no_bound = 1;
           
        % Wenn: Pixel == true und strike_le_bound == 1 und
        % strike_no_bound == 1
        % d.H.: Zeile N Spalte M rechte Grenze gefunden
        elseif cur_pix_val == true && strike_le_bound == 1 && strike_no_bound == 1
            pix_koord_ri_bound = [j+1 i+1];
            strike_ri_bound = 1;
            strike_no_bound = 0;
           
        elseif i == size(org_gray_img, 2) && strike_le_bound == 1
            pix_koord_ri_bound = [j+1 i+1];
            strike_ri_bound = 1;
            strike_no_bound = 0;
        end
         
        % Wenn: strike_le_bound == 1 und strike_ri_bound == 1
        % d.H.: linke und rechte GrenzKoordinaten gefunden -> starte
        % Berechnungen und binarisiere Bild Zeilen und zusätzlich Teilweise
        if strike_le_bound == 1 && strike_ri_bound == 1
           
            cur_sum = my_sum_fun(gray_img, window_size, pix_koord_le_bound);
            cur_sum = cur_sum + my_sum_fun(gray_img, window_size, pix_koord_ri_bound);        
            cur_mean = cur_sum / 18;
                   
        % Indizierung auf Originalbild anpassen.
            m = pix_koord_le_bound(1, 1);
            n = pix_koord_le_bound(1, 2);
            p = pix_koord_ri_bound(1, 1);
            q = pix_koord_ri_bound(1, 2);
           
            row_start = m -1;  row_end = p - 1;  col_start = n -1;  col_end = q - 1;
            row_bin_img(row_start:row_end, col_start:col_end) = org_gray_img(row_start:row_end, col_start:col_end) > cur_mean;
            %row_bin_img(m:p, n:q) = boundary_map(m:p, n:q) > cur_mean;
           
        % KontrollVariablen zurücksetzen
            if i < size(org_gray_img, 2)
                last_pix_koord_ri_bound = pix_koord_ri_bound;
                controllVar_copyBound = 1;
            elseif i > size(org_gray_img, 2)
                last_pix_koord_ri_bound = 0;
                controllVar_copyBound = 0;
            end
           
            strike_le_bound = 0;
            strike_ri_bound = 0;
            pix_koord_le_bound = 0;
            pix_koord_ri_bound = 0;
        end  
    end
   
    pix_koord_le_bound = 0;
    pix_koord_ri_bound = 0;
    last_pix_koord_ri_bound = 0;

    strike_le_bound = 0;
    strike_ri_bound = 0;
    strike_no_bound = 0;
end

done_img = bitand(row_bin_img, col_bin_img);
 


Und letztlich die my_sum_fun.m
Code:

function o_sum = my_sum_fun(img, window_size, coords)

% abgerundete halbe Fenstergröße
sz = floor(window_size/2);

% Wenn Koordinaten kleiner gleich / größer gleich sz dann:
% ZeroPadding -> Indizierung anders.
if coords(1, 1) <= sz | coords(1, 2) <= sz | coords(1, 1) >= size(img,1) | coords(1, 2) >= size(img,2)
    tmp_img = padarray(img, [sz sz]);
    tmp = tmp_img(coords(1, 1):coords(1, 1)+window_size , coords(1, 2):coords(1, 2)+window_size);
else
    tmp = img(coords(1, 1)-sz:coords(1, 1)+sz , coords(1, 2)-sz:coords(1, 2)+sz);
end

o_sum = sum(tmp(:));
 



Mein Output (F1) habe ich angehängt, schaut aber leider noch nicht ganz wie im PDF aus. Die zwischenergebnisse sehen leider aber auch schon nicht aus wie im PDF.

Bspw. der Output in Zeile 16 / 17 ( Canny-Kanten-Grauwert Bild mit Schwellwert 0.001 )... Im Code ist der Schwellwert zwar auf 0.1, aber das liegt einzig allein daran das ich so bessere Ergebnisse heraus bekomme. Wenn ich den Schwellwert wie im PDF beschrieben auf 0.001 setze, erhalte ich zwar nicht viel mehr Kanten als im PDF, aber das fertig binarisierte Bild F1 wird meines empfindens nach nicht besser.

Einzig allein das Varianzbild sieht ungefähr so aus wie es soll. Aber das Kantenbild des Varianzbildes (boundary map / EG1) entspricht leider nicht ganz dem was ich im PDF sehe.
Ich habe versucht die Input Bilder mit einem 5x5 Gauß-Filter zu glätten und so das Rauschen zu minimieren, aber das hat nicht wirklich was gebracht. Auch andere Masken habe ich versucht oder die Prinzipien der Canny-Kanten-Filterung mehr oder weniger selbst auf die Bilder anzuwenden ohne die edge() - Funktion zu benutzten, was abeer auch kein Mhergewinn war.


Ein weiterer Punkt ist die Funktion compCC. Diese vergleicht zusammenhängende Pixel-Gebiete die von der bwboundaries() Funktion aus den Zeilen 44 und 55 zurückgegeben werden. Allerdings ist es ja so, dass Pixel-Gebiete zusammenhängend sind wenn die Pixel angrenzen und nicht wie in der Funktion compCC, sobald ein Pixel aus beiden Mengen übereinstimmt.
Hat jemand einen Tipp wie ich das prüfen kann ohne in der Funktion compCC weitere for loops zu öfnnen um an die Inhalte der einzelnen Matrizen der Cell-Arrays zugelangen?

Je nach Bild und verwendeten Schwellwerten für die Kanten-Filter sind hier bis zu 10k Komponenten pro Zelle vorhanden, mit Pixel-Gebieten die zwischen bspw. 4 bis 50 Pixel groß sein können. Dadurch wird die compCC Funktion meiner erachtens nach sehr rechenintensiv.


Ich bedanke mich schonmal für alle Anregungen, Hilfestellungen, Tipps und Verbesserungsvorschläge.

Bis dahin und euch allen eine schöne Woche Smile

F1.fig
 Beschreibung:

Download
 Dateiname:  F1.fig
 Dateigröße:  161.5 KB
 Heruntergeladen:  166 mal
Private Nachricht senden Benutzer-Profile anzeigen
 
Neues Thema eröffnen Neue Antwort erstellen



Einstellungen und Berechtigungen
Beiträge der letzten Zeit anzeigen:

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
.





 Impressum  | Nutzungsbedingungen  | Datenschutz | FAQ | goMatlab RSS Button RSS

Hosted by:


Copyright © 2007 - 2024 goMatlab.de | Dies ist keine offizielle Website der Firma The Mathworks

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.