XXL Nutrition

Sticky Wat heeft jouw dag verpest?

lul
 
GetXXL zei:
Heb de paper nogmaals doorgelezen en ben ditmaal wel voor de wiskunde gaan zitten, duizendmaal duidelijker nu. Snap nu hoe retarded het stond wat ik had geimplementeerd :roflol:
Klik om te vergroten...
Klik om te verkleinen...

Hahaha ook dat komt me bekend voor. Of dat je net een heel algoritme hebt geschreven, denken dat je het begrijpt en als je dan aan het einde van het algoritme bent het kwartje ineens valt. Kan je de helft weer verwijderen :o

GetXXL zei:
Van 150 regels code naar 14 (hoewel ik wel het 'domme' algoritme nu heb geimplementeerd). Snap wel waarom m'n docent er zo raar van op keek.
Klik om te vergroten...
Klik om te verkleinen...

Nice haha, wat heb je uiteindelijk gedaan?
 
Kevinson zei:
Hahaha ook dat komt me bekend voor. Of dat je net een heel algoritme hebt geschreven, denken dat je het begrijpt en als je dan aan het einde van het algoritme bent het kwartje ineens valt. Kan je de helft weer verwijderen :o



Nice haha, wat heb je uiteindelijk gedaan?
Klik om te vergroten...
Klik om te verkleinen...
Ongeveer dit:
Code: 
bitwise_or(marker, mask, mrk);
do {
    prev = mrk.clone();
    erode(mrk, mrk, se);
    bitwise_or(mrk, mask, mrk);
} while(!stability_reached(prev));

Vraag me overigens niet waarom ik erode moest gebruiken. Dilate eroseerde, en erode dilateerde gek genoeg. Maar goed, ondanks dat dit 'n implementatie is, is het niet de sequentiele implementatie zoals beschreven door Vincent, dus heb er alweer hoofdpijn over. Zit op 'n regeltje of 80 al voor die. Moet daar immers m'n eigen dilatie functie voor schrijven omdat je per se raster of anti-raster de pixels langs moet gaan om te dilateren. En dan moet je weer rekening houden met de neighbourhood die je gebruikt waarbij je onderscheid moet maken tussen Ng+ en Ng-, waarbij + de buren zijn die al geitereerd zijn voordat je bij de betreffende pixel p aankomt in raster-mode, en Ng- het tegenovergestelde. Dus bij 3x3:
Code: 
+ + +
+ X -
- - -
En dan krijg je dus dit soort shit:
Code: 
    // Ng+(p)
    if(neighbourhood) {
        int offset = -1;
        for(int i = p.y; i >= p.y - ((se_size.height - 1) / 2); i--) {
            offset++;
            for(int j = p.x + offset; j >= p.x - ((se_size.width - 1) / 2); j--) {
                if(marker.at<uchar>(j, i) > max) {
                    max = marker.at<uchar>(j, i);
                }
            }
        }
    }

Ik vraag me echt af hoe minder begaafde mensen dit soort shit aanpakken en proggen :roflol:
 
Laatst bewerkt:
GetXXL zei:
Ongeveer dit:
Code: 
bitwise_or(marker, mask, mrk);
do {
    prev = mrk.clone();
    erode(mrk, mrk, se);
    bitwise_or(mrk, mask, mrk);
} while(!stability_reached(prev));

Vraag me overigens niet waarom ik erode moest gebruiken. Dilate eroseerde, en erode dilateerde gek genoeg. Maar goed, ondanks dat dit 'n implementatie is, is het niet de sequentiele implementatie zoals beschreven door Vincent, dus heb er alweer hoofdpijn over. Zit op 'n regeltje of 80 al voor die. Moet daar immers m'n eigen dilatie functie voor schrijven omdat je per se raster of anti-raster de pixels langs moet gaan om te dilateren. En dan moet je weer rekening houden met de neighbourhood die je gebruikt waarbij je onderscheid moet maken tussen Ng+ en Ng-, waarbij + de buren zijn die al geitereerd zijn voordat je bij de betreffende pixel p aankomt in raster-mode, en Ng- het tegenovergestelde. En dan krijg je dus dit soort shit:
Code: 
    // Ng+(p)
    if(neighbourhood) {
        int offset = -1;
        for(int i = p.y; i >= p.y - ((se_size.height - 1) / 2); i--) {
            offset++;
            for(int j = p.x + offset; j >= p.x - ((se_size.width - 1) / 2); j--) {
                if(marker.at<uchar>(j, i) > max) {
                    max = marker.at<uchar>(j, i);
                }
            }
        }
    }
Klik om te vergroten...
Klik om te verkleinen...

Bedankt voor de credits.
 
GetXXL zei:
Ongeveer dit:
Code: 
bitwise_or(marker, mask, mrk);
do {
    prev = mrk.clone();
    erode(mrk, mrk, se);
    bitwise_or(mrk, mask, mrk);
} while(!stability_reached(prev));
Vraag me overigens niet waarom ik erode moest gebruiken. Dilate eroseerde, en erode dilateerde gek genoeg. Maar goed, ondanks dat dit 'n implementatie is, is het niet de sequentiele implementatie zoals beschreven door Vincent, dus heb er alweer hoofdpijn over. Zit op 'n regeltje of 80 al voor die. Moet daar immers m'n eigen dilatie functie voor schrijven omdat je per se raster of anti-raster de pixels langs moet gaan om te dilateren. En dan moet je weer rekening houden met de neighbourhood die je gebruikt waarbij je onderscheid moet maken tussen Ng+ en Ng-, waarbij + de buren zijn die al geitereerd zijn voordat je bij de betreffende pixel p aankomt in raster-mode, en Ng- het tegenovergestelde. Dus bij 3x3:
Code: 
+ + +
+ X -
- - -
En dan krijg je dus dit soort shit:
Code: 
    // Ng+(p)
    if(neighbourhood) {
        int offset = -1;
        for(int i = p.y; i >= p.y - ((se_size.height - 1) / 2); i--) {
            offset++;
            for(int j = p.x + offset; j >= p.x - ((se_size.width - 1) / 2); j--) {
                if(marker.at<uchar>(j, i) > max) {
                    max = marker.at<uchar>(j, i);
                }
            }
        }
    }
Ik vraag me echt af hoe minder begaafde mensen dit soort shit aanpakken en proggen :roflol:
Klik om te vergroten...
Klik om te verkleinen...

Hieronder wat meer uitleg over dilation/erosion.

Erosion

Bij erode haal je telkens een randje weg en doe je door te kijken of alle pixels van je structuring element in het object zitten. Dat is tenminste bij binair zo. Bij grayscale is het een tikkeltje anders:

Pak voor elke pixel (zeg P) in je originele afbeelding de grijswaarde. Pak van elke neighbor die in je structuring element ligt de waarde en stop die in een set. Pak de laagste waarde uit die set en dat is de waarde in je nieuwe afbeelding op locatie P (na de erosion step).

Stel je structuring element is:
Code: 
XXX
XXX
XXX

En je mask (originele afbeelding):
Code: 
5 9 3 2 4 5
0 2 9 5 9 4
0 0 3 9 8 5
0 0 0 0 9 4
0 0 0 0 0 1

Na 1 erosion krijg je dan :
Code: 
0 0 2 2 2 4
0 0 0 2 2 4
0 0 0 0 0 4
0 0 0 0 0 0
0 0 0 0 0 0

Na 2 erosions:
Code: 
0 0 0 0 2 2
0 0 0 0 0 0
0 0 0 0 0 0
0 0 0 0 0 0
0 0 0 0 0 0

Dilation

Zelfde als bij erosion, maar in plaats van MIN gebruik je MAX.

Stel je originele afbeelding, zonder dilations, is:
Code: 
0 0 2 2 2 4
0 0 0 2 2 4
0 0 0 0 0 4
0 0 0 0 0 0
0 0 0 0 0 0

Na 1 dilation:
Code: 
0 2 2 2 4 4
0 2 2 2 4 4
0 0 2 2 4 4
0 0 0 0 4 4
0 0 0 0 0 0
 
Ik snap erosion en dilation, maar ik snap juist niet waarom erode in openCV dilateerde en dilate eroseerde :roflol:

Ik had het zelf zo omschreven:
2cdbs55.png


En zoals je ziet dacht ik toen al dat de marker synoniem was voor de structuring element :o
 
Laatst bewerkt:
Ik begrijp wat hij bedoelt, maar dat is puur omdat ik voorkennis m.b.t. onderwerp heb. Raad je aan om die reader te gebruiken als naslagwerk, vind ik wel duidelijk.

Je zou dilation nu vrij simpel moeten kunnen schrijven, of moet je het doen zoals die paper aangeeft en niet met MAX?

edit: ben die pseudocode aan het lezen en snap het idee, moment.
 
Kevinson zei:
Ik begrijp wat hij bedoelt, maar dat is puur omdat ik voorkennis m.b.t. onderwerp heb. Raad je aan om die reader te gebruiken als naslagwerk, vind ik wel duidelijk.

Je zou dilation nu vrij simpel moeten kunnen schrijven, of moet je het doen zoals die paper aangeeft en niet met MAX?

edit: ben die pseudocode aan het lezen en snap het idee, moment.
Klik om te vergroten...
Klik om te verkleinen...
Snap ook in grote lijnen wat ie bedoelt, maar helder vind ik het niet.

Heb in principe m'n sequentiele algoritme nu 'af', loop alleen aan tegen wat memory allocatie errors nu :o

Code: 
    if(raster) {
        for(int y = 0; y < mask.rows; y++) {
            for(int x = 0; x < mask.cols; x++) {
                max = get_local_max(Point(x, y), true, marker, se_size);
                marker.at<uchar>(x, y) = get_min(max, mask.at<uchar>(x, y));
            }
        }
    }
En m'n get_local_max doet die shit dus met die neighbourhood, et voila. Seq algoritme geimplementeerd. Nu alleen nog die mem allocatie errors fixen. Ik wil garbage collector potverdomme.
 
Laatst bewerkt:
GetXXL zei:
Snap ook in grote lijnen wat ie bedoelt, maar helder vind ik het niet.

Heb in principe m'n sequentiele algoritme nu 'af', loop alleen aan tegen wat memory allocatie errors nu :o

Code: 
    if(raster) {
        for(int y = 0; y < mask.rows; y++) {
            for(int x = 0; x < mask.cols; x++) {
                max = get_local_max(Point(x, y), true, marker, se_size);
                marker.at<uchar>(x, y) = get_min(max, mask.at<uchar>(x, y));
            }
        }
    }
En m'n get_local_max doet die shit dus met die neighbourhood, et voila. Seq algoritme geimplementeerd. Nu alleen nog die mem allocatie errors fixen. Ik wil garbage collector potverdomme.
Klik om te vergroten...
Klik om te verkleinen...

Die sequentieel is precies zoals ik zei (met MAX), maar dan in 2 richtingen en de waarde wordt direct in het origineel geplaatst i.p.v. een nieuwe afbeelding. Moet een eitje zijn toch? Moet trouwens ook geen memerror opleveren.

Code: 
bool changed = true;
while(changed)
{
changed = false;

 //raster
 for(int x = 0; x < mask.cols; x++)
 {
    for(int y = 0; y < mask.rows; y++)
    {
           //voor elke neighbor, vergelijk met (x, y), als groter dan (x, y), vervang (x, y)
//als vervangen: changed = true;
     }
 }

  //anti-raster
//omgekeerde
}
 
Kevinson zei:
Hieronder wat meer uitleg over dilation/erosion.

Erosion

Bij erode haal je telkens een randje weg en doe je door te kijken of alle pixels van je structuring element in het object zitten. Dat is tenminste bij binair zo. Bij grayscale is het een tikkeltje anders:

Pak voor elke pixel (zeg P) in je originele afbeelding de grijswaarde. Pak van elke neighbor die in je structuring element ligt de waarde en stop die in een set. Pak de laagste waarde uit die set en dat is de waarde in je nieuwe afbeelding op locatie P (na de erosion step).

Stel je structuring element is:
Code: 
XXX
XXX
XXX

En je mask (originele afbeelding):
Code: 
5 9 3 2 4 5
0 2 9 5 9 4
0 0 3 9 8 5
0 0 0 0 9 4
0 0 0 0 0 1

Na 1 erosion krijg je dan :
Code: 
0 0 2 2 2 4
0 0 0 2 2 4
0 0 0 0 0 4
0 0 0 0 0 0
0 0 0 0 0 0

Na 2 erosions:
Code: 
0 0 0 0 2 2
0 0 0 0 0 0
0 0 0 0 0 0
0 0 0 0 0 0
0 0 0 0 0 0

Dilation

Zelfde als bij erosion, maar in plaats van MIN gebruik je MAX.

Stel je originele afbeelding, zonder dilations, is:
Code: 
0 0 2 2 2 4
0 0 0 2 2 4
0 0 0 0 0 4
0 0 0 0 0 0
0 0 0 0 0 0

Na 1 dilation:
Code: 
0 2 2 2 4 4
0 2 2 2 4 4
0 0 2 2 4 4
0 0 0 0 4 4
0 0 0 0 0 0
Klik om te vergroten...
Klik om te verkleinen...

GetXXL zei:
Ik snap erosion en dilation, maar ik snap juist niet waarom erode in openCV dilateerde en dilate eroseerde :roflol:

Ik had het zelf zo omschreven:
http://i42.tinypic.com/2cdbs55.png

En zoals je ziet dacht ik toen al dat de marker synoniem was voor de structuring element :o
Klik om te vergroten...
Klik om te verkleinen...

GetXXL zei:
En dit is hoe m'n docent het trachtte uit te leggen destijds:

http://i42.tinypic.com/5boifd.jpg

http://img0.joyreactor.cc/pics/post/mickey-mouse-Disney-глаза-песочница-435420.jpeg



:roflol:
Klik om te vergroten...
Klik om te verkleinen...

GetXXL zei:
Snap ook in grote lijnen wat ie bedoelt, maar helder vind ik het niet.

Heb in principe m'n sequentiele algoritme nu 'af', loop alleen aan tegen wat memory allocatie errors nu :o

Code: 
    if(raster) {
        for(int y = 0; y < mask.rows; y++) {
            for(int x = 0; x < mask.cols; x++) {
                max = get_local_max(Point(x, y), true, marker, se_size);
                marker.at<uchar>(x, y) = get_min(max, mask.at<uchar>(x, y));
            }
        }
    }
En m'n get_local_max doet die shit dus met die neighbourhood, et voila. Seq algoritme geimplementeerd. Nu alleen nog die mem allocatie errors fixen. Ik wil garbage collector potverdomme.
Klik om te vergroten...
Klik om te verkleinen...

Kevinson zei:
Die sequentieel is precies zoals ik zei (met MAX), maar dan in 2 richtingen en de waarde wordt direct in het origineel geplaatst i.p.v. een nieuwe afbeelding. Moet een eitje zijn toch? Moet trouwens ook geen memerror opleveren.

Code: 
bool changed = true;
while(changed)
{
changed = false;

 //raster
 for(int x = 0; x < mask.cols; x++)
 {
    for(int y = 0; y < mask.rows; y++)
    {
           //voor elke neighbor, vergelijk met (x, y), als groter dan (x, y), vervang (x, y)
//als vervangen: changed = true;
     }
 }

  //anti-raster
//omgekeerde
}
Klik om te vergroten...
Klik om te verkleinen...


[Afbeelding niet meer beschikbaar]
 
Ja, je kunt veel zeggen van GetXXL maar z'n posts zijn altijd van hoog niveau, zelfs geen occasioneel getrol.
 
Inloggen of registreren om te reageren.

Soortgelijke topics

R
IVDM - September 2017 - Robke78
2
Reacties
29
Weergaven
11.028
sector
sector
R
Aankondiging Forumgame 10: The war between two ideologies
28 29 30
Reacties
595
Weergaven
30.561
Remi AFCA
R
L
Forum game 8: Voor de niet valsspelers only
64 65 66
Reacties
1.313
Weergaven
50.218
z1000
z1000
The Dutch Giant
  • Sticky
Sticky Rise of the Dutch Giant (2.18meter / 7.2feet)
133 134 135
Reacties
2.690
Weergaven
543.587
spitfire01
spitfire01
Terug
Naar boven