robocars/robocar-road
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

fix: compile after gocv upgrade

Browse Source
This commit is contained in:
Cyrille Nofficial 2021-10-12 23:05:10 +02:00
parent ffb34da5de
commit 41083cb023
6 changed files with 94 additions and 88 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
build-docker.sh
View File

@ -126,10 +126,6 @@ image_final(){
#buildah rmi localhost/$IMAGE_NAME #buildah rmi localhost/$IMAGE_NAME
#buildah manifest rm localhost/${IMAGE_NAME} #buildah manifest rm localhost/${IMAGE_NAME}
image_build linux/amd64
image_build linux/arm64
image_build linux/arm/v7
image_build image_build
# push image # push image

31
part/opencv.go
View File

@ -44,7 +44,7 @@ func NewRoadDetector() *RoadDetector {
} }
} }
func (rd *RoadDetector) DetectRoadContour(imgGray *gocv.Mat, horizonRow int) *[]image.Point { func (rd *RoadDetector) DetectRoadContour(imgGray *gocv.Mat, horizonRow int) *gocv.PointVector {
kernel := gocv.NewMatWithSizeFromScalar(gocv.NewScalar(1, 1, 1, 1), rd.kernelSize, rd.kernelSize, gocv.MatTypeCV8U) kernel := gocv.NewMatWithSizeFromScalar(gocv.NewScalar(1, 1, 1, 1), rd.kernelSize, rd.kernelSize, gocv.MatTypeCV8U)
@ -77,34 +77,37 @@ func (rd *RoadDetector) DetectRoadContour(imgGray *gocv.Mat, horizonRow int) *[]
return rd.detectRoadContour(&img) return rd.detectRoadContour(&img)
} }
func (rd *RoadDetector) detectRoadContour(imgInversed *gocv.Mat) *[]image.Point { func (rd *RoadDetector) detectRoadContour(imgInversed *gocv.Mat) *gocv.PointVector {
var ( var (
epsilon float64 epsilon float64
cntr []image.Point cntr gocv.PointVector
) )
cntrs := gocv.FindContours(*imgInversed, gocv.RetrievalExternal, gocv.ChainApproxSimple) ptsVec := gocv.FindContours(*imgInversed, gocv.RetrievalExternal, gocv.ChainApproxSimple)
defer ptsVec.Close()
if len(cntrs) == 0 { if ptsVec.Size() == 0 {
emptyContours := make([]image.Point, 0) emptyContours := gocv.NewPointVector()
return &emptyContours return &emptyContours
} else if len(cntrs) == 1 { } else if ptsVec.Size() == 1 {
epsilon = rd.approxPolyEpsilonFactor * gocv.ArcLength(cntrs[0], true) epsilon = rd.approxPolyEpsilonFactor * gocv.ArcLength(ptsVec.At(0), true)
cntr = cntrs[0] cntr = ptsVec.At(0)
} else { } else {
// Search biggest contour // Search biggest contour
peris := make([]float64, len(cntrs)) peris := make([]float64, ptsVec.Size())
maxArcIdx := 0 maxArcIdx := 0
maxArcValue := 0. maxArcValue := 0.
for i, c := range cntrs { //for i, c := range cntrs {
for i := 0; i< ptsVec.Size(); i++ {
c := ptsVec.At(i)
peri := gocv.ArcLength(c, true) peri := gocv.ArcLength(c, true)
peris[i] = peri peris[i] = peri
if peri > maxArcValue { if peri > maxArcValue {
maxArcValue = peri maxArcValue = peri
maxArcIdx = i maxArcIdx = i
} }
cntr = cntrs[maxArcIdx] cntr = ptsVec.At(maxArcIdx)
} }
epsilon = rd.approxPolyEpsilonFactor * peris[maxArcIdx] epsilon = rd.approxPolyEpsilonFactor * peris[maxArcIdx]
} }
@ -114,8 +117,8 @@ func (rd *RoadDetector) detectRoadContour(imgInversed *gocv.Mat) *[]image.Point
var EllipseNotFound = events.Ellipse{Confidence: 0.} var EllipseNotFound = events.Ellipse{Confidence: 0.}
func (rd *RoadDetector) ComputeEllipsis(road *[]image.Point) *events.Ellipse { func (rd *RoadDetector) ComputeEllipsis(road *gocv.PointVector) *events.Ellipse {
if len(*road) < 5 { if road.Size() < 5 {
return &EllipseNotFound return &EllipseNotFound
} }

45
part/opencv_test.go
View File

@ -65,42 +65,51 @@ func TestRoadDetection_DetectRoadContour(t *testing.T) {
[]image.Point{image.Point{0, 45}, image.Point{0, 127}, image.Point{144, 127}, image.Point{95, 21}, image.Point{43, 21}}, []image.Point{image.Point{0, 45}, image.Point{0, 127}, image.Point{144, 127}, image.Point{95, 21}, image.Point{43, 21}},
}, },
{"image2", img2, 20, {"image2", img2, 20,
[]image.Point{{159,69}, {128,53}, {125,41}, {113,42}, {108,21}, {87,21}, {79,41}, {72,30}, {44,39}, {29,34}, {0,67}, {0,127}, {159,127}, {152,101},}, []image.Point{{159, 69}, {128, 53}, {125, 41}, {113, 42}, {108, 21}, {87, 21}, {79, 41}, {72, 30}, {44, 39}, {29, 34}, {0, 67}, {0, 127}, {159, 127}, {152, 101}},
}, },
{"image3", img3, 20, {"image3", img3, 20,
[]image.Point{{97,21}, {59,127}, {159,127}, {159,36}, {138,21},}, []image.Point{{97, 21}, {59, 127}, {159, 127}, {159, 36}, {138, 21}},
}, },
{"image4", img4, 20, {"image4", img4, 20,
[]image.Point{{0,21}, {0,77}, {68,22}, {0,96}, {0,127}, {159,127}, {159,21},}, []image.Point{{0, 21}, {0, 77}, {68, 22}, {0, 96}, {0, 127}, {159, 127}, {159, 21}},
}, },
{"image5", img5, 20, {"image5", img5, 20,
[]image.Point{{159,32}, {100,36}, {29,60}, {0,79}, {0,127}, {159,127},}, []image.Point{{159, 32}, {100, 36}, {29, 60}, {0, 79}, {0, 127}, {159, 127}},
}, },
} }
for _, c := range cases { for _, c := range cases {
imgGray := toGray(*c.img) imgGray := toGray(*c.img)
contours := rd.DetectRoadContour(imgGray, c.horizon) contours := rd.DetectRoadContour(imgGray, c.horizon)
imgGray.Close()
log.Infof("[%v] contour: %v", c.name, *contours) log.Infof("[%v] contour: %v", c.name, *contours)
if len(*contours) != len(c.expectedContour) { expected := gocv.NewPointVectorFromPoints(c.expectedContour)
t.Errorf("[%v] bad contour size: %v point(s), wants %v", c.name, len(*contours), len(c.expectedContour))
if contours.Size() != expected.Size() {
t.Errorf("[%v] bad contour size: %v point(s), wants %v", c.name, contours.Size(), expected.Size())
} }
for idx, pt := range c.expectedContour { for idx := 0; idx< expected.Size(); idx++ {
if pt != (*contours)[idx] { pt := expected.At(idx)
t.Errorf("[%v] bad point: %v, wants %v", c.name, (*contours)[idx], pt) if pt != contours.At(idx) {
t.Errorf("[%v] bad point: %v, wants %v", c.name, contours.At(idx), pt)
} }
} }
debugContour(*c.img, contours, fmt.Sprintf("/tmp/%v.jpg", c.name)) debugContour(*c.img, contours, fmt.Sprintf("/tmp/%v.jpg", c.name))
expected.Close()
imgGray.Close()
contours.Close()
} }
} }
func debugContour(img gocv.Mat, contour *[]image.Point, imgPath string) { func debugContour(img gocv.Mat, contour *gocv.PointVector, imgPath string) {
imgColor := img.Clone() imgColor := img.Clone()
defer imgColor.Close() defer imgColor.Close()
gocv.DrawContours(&imgColor, [][]image.Point{*contour,}, 0, color.RGBA{ ptsVec := gocv.NewPointsVector()
defer ptsVec.Close()
ptsVec.Append(*contour)
gocv.DrawContours(&imgColor, ptsVec, 0, color.RGBA{
R: 0, R: 0,
G: 255, G: 255,
B: 0, B: 0,
@ -131,7 +140,7 @@ func TestRoadDetector_ComputeEllipsis(t *testing.T) {
}, },
}, },
{"image2", {"image2",
[]image.Point{{159,69}, {128,53}, {125,41}, {113,42}, {108,21}, {87,21}, {79,41}, {72,30}, {44,39}, {29,34}, {0,67}, {0,127}, {159,127}, {152,101},}, []image.Point{{159, 69}, {128, 53}, {125, 41}, {113, 42}, {108, 21}, {87, 21}, {79, 41}, {72, 30}, {44, 39}, {29, 34}, {0, 67}, {0, 127}, {159, 127}, {152, 101}},
events.Ellipse{ events.Ellipse{
Center: &events.Point{ Center: &events.Point{
X: 77, X: 77,
@ -144,7 +153,7 @@ func TestRoadDetector_ComputeEllipsis(t *testing.T) {
}, },
}, },
{"image3", {"image3",
[]image.Point{{97,21}, {59,127}, {159,127}, {159,36}, {138,21},}, []image.Point{{97, 21}, {59, 127}, {159, 127}, {159, 36}, {138, 21}},
events.Ellipse{ events.Ellipse{
Center: &events.Point{ Center: &events.Point{
X: 112, X: 112,
@ -157,7 +166,7 @@ func TestRoadDetector_ComputeEllipsis(t *testing.T) {
}, },
}, },
{"image4", {"image4",
[]image.Point{{0,21}, {0,77}, {68,22}, {0,96}, {0,127}, {159,127}, {159,21},}, []image.Point{{0, 21}, {0, 77}, {68, 22}, {0, 96}, {0, 127}, {159, 127}, {159, 21}},
events.Ellipse{ events.Ellipse{
Center: &events.Point{ Center: &events.Point{
X: 86, X: 86,
@ -170,7 +179,7 @@ func TestRoadDetector_ComputeEllipsis(t *testing.T) {
}, },
}, },
{"image5", {"image5",
[]image.Point{{159,32}, {100,36}, {29,60}, {0,79}, {0,127}, {159,127},}, []image.Point{{159, 32}, {100, 36}, {29, 60}, {0, 79}, {0, 127}, {159, 127}},
events.Ellipse{ events.Ellipse{
Center: &events.Point{ Center: &events.Point{
X: 109, X: 109,
@ -185,7 +194,9 @@ func TestRoadDetector_ComputeEllipsis(t *testing.T) {
} }
for _, c := range cases { for _, c := range cases {
ellipse := rd.ComputeEllipsis(&c.contour) ct := gocv.NewPointVectorFromPoints(c.contour)
ellipse := rd.ComputeEllipsis(&ct)
ct.Close()
if ellipse.String() != c.expectedEllipse.String() { if ellipse.String() != c.expectedEllipse.String() {
t.Errorf("ComputeEllipsis(%v): %v, wants %v", c.name, ellipse.String(), c.expectedEllipse.String()) t.Errorf("ComputeEllipsis(%v): %v, wants %v", c.name, ellipse.String(), c.expectedEllipse.String())
} }

24
part/part.go
View File

@ -23,7 +23,6 @@ func NewRoadPart(client mqtt.Client, horizon int, cameraTopic, roadTopic string)
return &RoadPart{ return &RoadPart{
client: client, client: client,
frameChan: make(chan frameToProcess), frameChan: make(chan frameToProcess),
readyForNext: make(chan interface{}, 1),
cancel: make(chan interface{}), cancel: make(chan interface{}),
roadDetector: NewRoadDetector(), roadDetector: NewRoadDetector(),
horizon: horizon, horizon: horizon,
@ -35,7 +34,6 @@ func NewRoadPart(client mqtt.Client, horizon int, cameraTopic, roadTopic string)
func (r *RoadPart) Start() error { func (r *RoadPart) Start() error {
registerCallBacks(r) registerCallBacks(r)
ready := true
var frame = frameToProcess{} var frame = frameToProcess{}
defer func() { defer func() {
if err := frame.Close(); err != nil { if err := frame.Close(); err != nil {
@ -52,13 +50,8 @@ func (r *RoadPart) Start() error {
if err := oldFrame.Close(); err != nil { if err := oldFrame.Close(); err != nil {
log.Errorf("unable to close msg: %v", err) log.Errorf("unable to close msg: %v", err)
} }
if ready {
log.Debug("process msg") log.Debug("process msg")
go r.processFrame(&frame) go r.processFrame(&frame)
ready = false
}
case <-r.readyForNext:
ready = true
case <-r.cancel: case <-r.cancel:
log.Infof("Stop service") log.Infof("Stop service")
return nil return nil
@ -73,15 +66,15 @@ var registerCallBacks = func(r *RoadPart) {
} }
} }
func (o *RoadPart) Stop() { func (r *RoadPart) Stop() {
defer func() { defer func() {
if err := o.roadDetector.Close(); err != nil { if err := r.roadDetector.Close(); err != nil {
log.Errorf("unable to close roadDetector: %v", err) log.Errorf("unable to close roadDetector: %v", err)
} }
}() }()
close(o.readyForNext) close(r.readyForNext)
close(o.cancel) close(r.cancel)
service.StopService("road", o.client, o.roadTopic) service.StopService("road", r.client, r.roadTopic)
} }
func (r *RoadPart) OnFrame(_ mqtt.Client, msg mqtt.Message) { func (r *RoadPart) OnFrame(_ mqtt.Client, msg mqtt.Message) {
@ -120,10 +113,13 @@ func (r *RoadPart) processFrame(frame *frameToProcess) {
gocv.CvtColor(img, &imgGray, gocv.ColorRGBToGray) gocv.CvtColor(img, &imgGray, gocv.ColorRGBToGray)
road := r.roadDetector.DetectRoadContour(&imgGray, r.horizon) road := r.roadDetector.DetectRoadContour(&imgGray, r.horizon)
defer road.Close()
ellipse := r.roadDetector.ComputeEllipsis(road) ellipse := r.roadDetector.ComputeEllipsis(road)
cntr := make([]*events.Point, 0, len(*road)) cntr := make([]*events.Point, 0, road.Size())
for _, pt := range *road { for i:=0;i< road.Size(); i++ {
pt := road.At(i)
cntr = append(cntr, &events.Point{X: int32(pt.X), Y: int32(pt.Y)}) cntr = append(cntr, &events.Point{X: int32(pt.X), Y: int32(pt.Y)})
} }

4
part/part_test.go
View File

@ -35,7 +35,7 @@ func TestRoadPart_OnFrame(t *testing.T) {
cameraTopic := "topic/camera" cameraTopic := "topic/camera"
roadTopic := "topic/road" roadTopic := "topic/road"
rp := NewRoadPart(nil, 20, roadTopic) rp := NewRoadPart(nil, 20, cameraTopic, roadTopic)
go func() { go func() {
if err := rp.Start(); err != nil { if err := rp.Start(); err != nil {
t.Errorf("unable to start roadPart: %v", err) t.Errorf("unable to start roadPart: %v", err)
@ -53,7 +53,7 @@ func TestRoadPart_OnFrame(t *testing.T) {
name: "image1", name: "image1",
msg: loadFrame(t, cameraTopic, "image"), msg: loadFrame(t, cameraTopic, "image"),
expectedCntr: []*events.Point{&events.Point{X: 0, Y: int32(45)}, &events.Point{X: 0, Y: 127}, &events.Point{X: 144, Y: 127}, &events.Point{X: 95, Y: 21}, &events.Point{X: 43, Y: 21}}, expectedCntr: []*events.Point{&events.Point{X: 0, Y: int32(45)}, &events.Point{X: 0, Y: 127}, &events.Point{X: 144, Y: 127}, &events.Point{X: 95, Y: 21}, &events.Point{X: 43, Y: 21}},
expectedEllipse: events.Ellipse{Center: &events.Point{X: 71, Y: 87,}, Width: 139, Height: 176, Angle: 92.66927, Confidence: 1.,}, expectedEllipse: events.Ellipse{Center: &events.Point{X: 71, Y: 87}, Width: 139, Height: 176, Angle: 92.66927, Confidence: 1.},
}, },
} }