Zvětšení obrazu: Nechte déšť, sníh. Jak modifikovat fotografie pro trénování autovláken

Image Augmentation je technika pro pořízení snímku a jeho použití pro generování nových. Je to užitečné pro věci, jako je trénink auta s vlastním řízením.

Myslete na osobu, která řídí auto za slunečného dne. Pokud začne pršet, může být zpočátku obtížné jet za deště. Ale pomalu si na to zvykají.

Umělá neuronová síť také považuje za matoucí řídit v novém prostředí, pokud ji dříve neviděla. Jedná se o různé augmentační techniky, jako je překlopení, překlad, přidání šumu nebo změna barevného kanálu.

V tomto článku se podívám na část počasí. Ke zpracování obrázků jsem použil knihovnu OpenCV. Po chvíli mi to připadalo docela snadné a do obrazu jsem byl schopen představit různé scénáře počasí.

Přitlačil jsem plně implementovaný notebook Jupyter, se kterým můžete hrát na GitHubu.

Pojďme se podívat.

Nejprve vám ukážu originální testovací obrázek a poté jej doplním.

Sunny a Shady

Po přidání náhodného slunečného a stinného efektu se jas obrázku změní. Je to snadná a rychlá transformace.

def add_brightness (obrázek):
    image_HLS = cv2.cvtColor (image, cv2.COLOR_RGB2HLS) ## Převod na HLS
    image_HLS = np.array (image_HLS, dtype = np.float64)
    random_brightness_coefficient = np.random.uniform () + 0,5 ## generuje hodnotu mezi 0,5 a 1,5
    image_HLS [:,:, 1] = image_HLS [:,:, 1] * random_brightness_coefficient ## měřítko hodnot pixelů nahoru nebo dolů pro kanál 1 (Lightness)
    image_HLS [:,:, 1] [image_HLS [:,:, 1]> 255] = 255 ## Nastaví všechny hodnoty nad 255 až 255
    image_HLS = np.array (image_HLS, dtype = np.uint8)
    image_RGB = cv2.cvtColor (image_HLS, cv2.COLOR_HLS2RGB) ## Převod na RGB
    návrat image_RGB

Jas obrazu lze změnit změnou hodnot obrazových bodů „Lightness“ - kanál 1 obrazu v barevném prostoru HLS. Převod obrazu zpět na RGB dává stejný obraz se zvýšeným nebo potlačeným osvětlením.

SlunnýStinné

Stíny

Stín není pro auto nic jiného než tmavé části obrazu, které mohou být občas jasné. Samohybné auto by se tedy mělo vždy naučit řídit se stíny nebo bez nich. Náhodně se měnící jas na kopcích nebo v lese často vnímá vnímání automobilu, pokud není správně vyškolen. To je ještě častější za slunečných dnů a různě vysokých budov ve městě, což umožňuje proniknout paprsky světla.

Jas je dobrý pro vnímání, ale nerovnoměrný, náhlý nebo příliš vysoký jas způsobuje problémy s vnímáním. Vytvořme nějaké falešné stíny.

defgenerate_shadow_coordinates (imshape, no_of_shadows = 1):
    vertices_list = []
    pro index v rozsahu (no_of_shadows):
        vertex = []
        pro rozměry v rozsahu (np.random.randint (3,15)): ## Dimenzionalita stínového polygonu
            vertex.append ((imshape [1] * np.random.uniform (), imshape [0] // 3 + imshape [0] * np.random.uniform ()))
        vertices = np.array ([vrchol], dtype = np.int32) ## single shadow vertices
        vertices_list.append (vertices)
    return vertices_list ## Seznam stínových vrcholů
def add_shadow (image, no_of_shadows = 1):
    image_HLS = cv2.cvtColor (image, cv2.COLOR_RGB2HLS) ## Převod na HLS
    mask = np.zeros_like (obrázek)
    imshape = image.shape
    vertices_list = generovat_shadow_coordinates (imshape, no_of_shadows) # 3 získává seznam stínových vrcholů
    pro vrcholy v vertices_list:
        cv2.fillPoly (maska, vrcholy, 255) ## přidání všech stínových polygonů na prázdnou masku, jeden 255 označuje pouze červený kanál
    
    image_HLS [:,:, 1] [maska ​​[:,:, 0] == 255] = image_HLS [:,:, 1] [maska ​​[:,:, 0] == 255] * 0,5 ##, pokud je červený kanál je horká, jas kanálu kanálu „Lightness“ je snížen
    image_RGB = cv2.cvtColor (image_HLS, cv2.COLOR_HLS2RGB) ## Převod na RGB
    návrat image_RGB

V tomto případě je funkce fillPoly () OpenCV opravdu užitečná. Vytvořme několik náhodných vrcholů a uložíme mnohoúhelník na prázdnou masku pomocí fillPoly (). Poté, co to uděláte, je jediné, co musíte udělat, je zkontrolovat masku pro horké pixely a snížit „Lightness“ v obrazu HLS, kdekoli jsou tyto horké pixely nalezeny.

Náhodný stín mnohoúhelník na silnici

Sníh

To je něco nového. Často se ptáme, jak by se naše vozidlo chovalo na zasněžených silnicích. Jedním ze způsobů, jak to otestovat, je získat fotky sněhových oděvů nebo udělat něco na obrázcích, abyste získali podobný efekt. Tento efekt není úplnou alternativou k zasněženým silnicím, ale je to přístup, který stojí za vyzkoušení.

def add_snow (obrázek):
    image_HLS = cv2.cvtColor (image, cv2.COLOR_RGB2HLS) ## Převod na HLS
    image_HLS = np.array (image_HLS, dtype = np.float64)
    brightness_coefficient = 2.5
    snow_point = 140 ## zvýšit toto pro více sněhu
    image_HLS [:,:, 1] [image_HLS [:,:, 1]  255] = 255 ## Nastaví všechny hodnoty nad 255 až 255
    image_HLS = np.array (image_HLS, dtype = np.uint8)
    image_RGB = cv2.cvtColor (image_HLS, cv2.COLOR_HLS2RGB) ## Převod na RGB
    návrat image_RGB

Jo! A je to. Tento kód obecně bělí nejtmavší části obrazu, což jsou většinou silnice, stromy, hory a další krajinné prvky, pomocí stejné metody zvýšení HLS „Lightness“ použité v ostatních výše uvedených přístupech. Tato technika nefunguje pro tmavé obrázky, ale můžete ji upravit. Zde je přehled toho, co získáte:

Zima je tady

Můžete vylepšit některé parametry v kódu pro více či méně sněhu než to. Testoval jsem to také na jiných obrázcích a tato technika mi způsobuje zimnici.

Déšť

Ano, slyšeli jste to správně. Proč neprší? Když lidé mají potíže s jízdou v dešti, proč by z toho měla být ušetřena vozidla? Ve skutečnosti je to jedna z situací, pro které chci, aby moje auto s vlastním pohonem bylo vyškoleno nejvíce. Kluzké silnice a rozmazané vize jsou riskantní a auta by měla vědět, jak s nimi zacházet.

defgener_random_lines (imshape, sklon, drop_length):
    drops = []
    pro i v rozsahu (1500): ## Pokud chcete silný déšť, zkuste to zvýšit
        pokud sklon <0:
            x = np.random.randint (šikmé, imshape [1])
        jiný:
            x = np.random.randint (0, imshape [1] -slant)
        y = np.random.randint (0, imshape [0] -drop_length)
        drops.append ((x, y))
    zpětné kapky
        
    
def add_rain (obrázek):
    
    imshape = image.shape
    slant_extreme = 10
    slant = np.random.randint (-slant_extreme, slant_extreme)
    drop_length = 20
    drop_width = 2
    drop_color = (200 200 200) ## odstín šedé
    rain_drops =gener_random_lines (imshape, sklon, drop_length)
    
    pro rain_drop v rain_drops:
        cv2.line (obrázek, (rain_drop [0], rain_drop [1]), (rain_drop [0] + sklon, rain_drop [1] + drop_length), drop_color, drop_width)
    image = cv2.blur (image, (7,7)) ## deštivé zobrazení je rozmazané
    
    brightness_coefficient = 0,7 ## deštivé dny jsou obvykle temné
    image_HLS = cv2.cvtColor (image, cv2.COLOR_RGB2HLS) ## Převod na HLS
    image_HLS [:,:, 1] = image_HLS [:,:, 1] * brightness_coefficient ## zmenšuje hodnoty pixelů pro kanál 1 (Lightness)
    image_RGB = cv2.cvtColor (image_HLS, cv2.COLOR_HLS2RGB) ## Převod na RGB
    návrat image_RGB

Zde jsem udělal to, že jsem znovu generoval náhodné body po celém obrázku a pak pomocí funkce OpenCV line () vytvořil malé řádky po celém obrázku. Také jsem použil náhodný sklon v dešťových kapkách, abych měl pocit skutečného deště. Také jsem snížil jas obrázku, protože deštivé dny jsou obvykle temné a také rozmazané kvůli dešti. Můžete změnit rozměr rozostření filtru a počet kapek deště pro požadovaný efekt.

Zde je výsledek:

Falešný déšť, ale ne moc rozmazané

Mlha

Toto je další scénář, který hodně brání vizi samohybného automobilu. Rozmazané bílé chmýří na obrázku ztěžuje vidění i přes určitý úsek a snižuje ostrost obrazu.

Intenzita mlhy je důležitým parametrem pro trénink automobilu o tom, kolik plynu by měl dávat. Pro kódování takové funkce můžete pořizovat náhodné záplaty z celého obrazu a v těchto záplatách zvyšovat světlost obrazu. S jednoduchým rozostřením to dává pěkný mlhavý efekt.

def add_blur (obrázek, x, y, hw):
    image [y: y + hw, x: x + hw, 1] = image [y: y + hw, x: x + hw, 1] +1
    image [:,:, 1] [image [:,:, 1]> 255] = 255 ## Nastaví všechny hodnoty nad 255 až 255
    obrázek [y: y + hw, x: x + hw, 1] = cv2.blur (obrázek [y: y + hw, x: x + hw, 1], (10,10))
    návratový obrázek
defgener_random_blur_coordinates (imshape, hw):
    blur_points = []
    midx = imshape [1] // 2-hw-100
    midy = imshape [0] // 2-hw-100
    index = 1
    while (midx> -100 nebo midy> -100): ## radiálně generující souřadnice
        pro i v rozsahu (250 * index):
            x = np.random.randint (midx, imshape [1] -midx-hw)
            y = np.random.randint (midy, imshape [0] -midy-hw)
            blur_points.append ((x, y))
        midx- = 250 * imshape [1] // součet (imshape)
        midy- = 250 * imshape [0] // součet (imshape)
        index + = 1
    návrat blur_points
    
def add_fog (obrázek):
    image_HLS = cv2.cvtColor (image, cv2.COLOR_RGB2HLS) ## Převod na HLS
    mask = np.zeros_like (obrázek)
    imshape = image.shape
    hw = 100
    image_HLS [:,:, 1] = image_HLS [:,:, 1] * 0.8
    haze_list = generator_random_blur_coordinates (imshape, hw)
    pro haze_points v haze_list:
        image_HLS [:,:, 1] [image_HLS [:,:, 1]> 255] = 255 ## Nastaví všechny hodnoty nad 255 až 255
        image_HLS = add_blur (image_HLS, haze_points [0], haze_points [1], hw) ## přidání všech stínových polygonů na prázdnou masku, jeden 255 označuje pouze červený kanál
    image_RGB = cv2.cvtColor (image_HLS, cv2.COLOR_HLS2RGB) ## Převod na RGB
    návrat image_RGB

Kódování to bylo nejtěžší ze všech výše uvedených funkcí. Zkoušel jsem radiální přístup, abych vytvořil záplaty zde. Protože v mlhavý den je většina mlhy na opačném konci silnice a jak se blížíme, vidění se stále čistí.

Foggy Highway

Je to skutečný obtížný úkol, když stroj detekuje blízká auta a jízdní pruhy v tak mlhavém stavu a je to dobrý způsob, jak trénovat a testovat robustnost modelu jízdy.

Občasný déšť

Přemýšlel jsem o tom, že trochu zlepší déšť kombinací mlhy a deště. Vzhledem k tomu, že během dešťů vždy dochází k určitému zákalu, je dobré na to také trénovat auto. K tomu není potřeba žádná nová funkce. Tento efekt můžeme dosáhnout postupným zavoláním obou.

Auto napravo je na tomto obrázku sotva viditelné, a to je scénář skutečného světa. Za silného deště nedokážeme na silnici téměř nic rozeznat.

Doufám, že tento článek vám pomůže model trénovat v různých povětrnostních podmínkách. Celý můj kód můžete navštívit v mém profilu GitHub. A napsal jsem spoustu dalších článků, které si můžete přečíst na médiu a na mém webu WordPress.

Užívat si!