Numpy: Het selecteren van abritrary vormen op basis van vorm hoeken

stemmen
1

Ik gebruik numpy indexering voor een tijdje nu. Maar ik heb alleen ooit moest basisvormen selecteren, zoals rechthoeken of schijven

Nochtans, moet ik nu in staat zijn om meer willekeurige vormen te kiezen en ik kan een goede manier om dit te doen vinden. Idealiter zou ik graag in staat zijn om een ​​lijst van hoeken en voor alle indices die binnen die hoeken te worden geselecteerd te geven. We kunnen aannemen dat de vormgegeven convex

Bijvoorbeeld, gegeven een matrix met nullen vorm (10, 10), door te proberen de waarden in de hoeken ((2,2), (6,3), (4,8) en (7,9) ) tot 1 zou dit een masker als zodanig terug te keren

  [[0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
   [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
   [0., 0., 1., 1., 1., 0., 0., 0., 0., 0.],
   [0., 0., 1., 1., 1., 1., 0., 0., 0., 0.],
   [0., 0., 1., 1., 1., 1., 1., 1., 1., 0.],
   [0., 0., 0., 1., 1., 1., 1., 1., 1., 0.],
   [0., 0., 0., 1., 1., 1., 1., 1., 1., 1.],
   [0., 0., 0., 0., 0., 0., 1., 1., 1., 1.],
   [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
   [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.]]

Nu is een van de problemen is dat er over het algemeen geen unieke oplossing voor dit probleem, maar het nemen van een plausibel is goed genoeg voor mij. Ik kan niet denken aan een manier om dit te doen met behulp van numpy echter, zoals alleen elementaire slicings en duidelijke wiskundige vergelijkingen te worden ondersteund.

Heeft iemand ooit lopen in een dergelijke uitdaging? Moet ik hun toevlucht nemen tot de meer traditionele python voor loops?

De vraag is gesteld op 09/10/2019 om 12:51
bron van user
In andere talen...                            


1 antwoorden

stemmen
2

Toegegeven een lelijke oplossing, maar hoe zit het genereren van een binair masker voor de selectie van uw polygoon via OpenCV en het gebruik van die ene?

import cv2
import numpy as np

corners = np.asarray([(2,2), (6,3), (4,8), (7,9)])

target = np.zeros([10,10])
mask = cv2.fillPoly(np.zeros_like(target, dtype=np.uint8), [corners], 255).astype(bool)

target[mask] = 1

genereert:

>>> target
array([[0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
       [0., 0., 1., 1., 1., 0., 0., 0., 0., 0.],
       [0., 0., 0., 1., 1., 1., 1., 0., 0., 0.],
       [0., 0., 0., 1., 1., 1., 1., 0., 0., 0.],
       [0., 0., 0., 0., 1., 1., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0., 1., 0., 0., 0., 0.],
       [0., 0., 0., 0., 1., 1., 1., 0., 0., 0.],
       [0., 0., 0., 0., 1., 1., 1., 0., 0., 0.],
       [0., 0., 0., 0., 0., 0., 1., 1., 0., 0.]], dtype=float32)

Opmerking : Ik ben met behulp van de hoeken in de volgorde waarin u ze heeft gegeven. Voor OpenCV, worden punten in een polygoon geïnterpreteerd orde (vandaar het verschil in vorm tussen mijn output en u). De volgorde van de hoeken dus precies de vorm die u nodig hebt (bijvoorbeeld met de klok mee) te verkrijgen.

Nota (2) : Ik ben het interpreteren van uw hoeken als (x, y), niet als (rij, kolom), omdat het niet in de vraag en OpenCV gebruik (x, y) conventie werd opgegeven voor de punten (terwijl numpy toepassingen (rij, kolom)).


Om de gewenste uitvoer te genereren, wisselen de coördinaten van de hoek en herschikken ze als volgt:

corners = np.asarray([(2,2), (6,3), (7,9), (4,8) ])[:,(1,0)]

Met deze (en de bovenstaande code) krijgt u:

>>> target
array([[0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
       [0., 0., 1., 1., 0., 0., 0., 0., 0., 0.],
       [0., 0., 1., 1., 1., 1., 1., 0., 0., 0.],
       [0., 0., 1., 1., 1., 1., 1., 1., 1., 0.],
       [0., 0., 0., 1., 1., 1., 1., 1., 1., 0.],
       [0., 0., 0., 1., 1., 1., 1., 1., 1., 1.],
       [0., 0., 0., 0., 0., 0., 0., 1., 1., 1.],
       [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.]], dtype=float32)
antwoordde op 09/10/2019 om 13:08
bron van user

Cookies help us deliver our services. By using our services, you agree to our use of cookies. Learn more