// ToImageRect converts a point in the feature pyramid to a rectangle in the image.
func (pyr *Generator) ToImageRect(level int, pt image.Point, interior image.Rectangle) image.Rectangle {
// Translate interior by position (scaled by rate) and subtract margin offset.
rate := pyr.Transform.Rate()
offset := pyr.Pad.Margin.TopLeft()
scale := pyr.Image.Scales[level]
rect := interior.Add(pt.Mul(rate)).Sub(offset)
return scaleRect(1/scale, rect)
}
func MinInputSize(feat image.Point, conf Config) image.Point {
// One feature pixel on all sides.
feat = feat.Add(image.Pt(2, 2))
// Multiply by cell size to get pixels.
pix := feat.Mul(conf.CellSize)
// Add floor(half a cell) on all sides.
half := conf.CellSize / 2
pix = pix.Add(image.Pt(half, half).Mul(2))
// Leave one pixel to compute derivatives.
pix = pix.Add(image.Pt(1, 1).Mul(2))
return pix
}
func eval(t *testing.T, path string, f storage.Image, size image.Point, colors []int) string {
var b []byte
w := bytes.NewBuffer(b)
p := processor.New()
f.ValidatedWidth *= u
f.ValidatedHeight *= u
pixels, err := p.Preprocess(path)
if err != nil {
t.Fatalf("cannot preprocess image: error=%v", err)
}
f, err = f.Normalize(pixels.Bounds().Size())
if err != nil {
t.Fatalf("fail to normalize: error=%v", err)
}
if _, err := p.Process(pixels, w, f); err != nil {
t.Fatalf("cannot process image: %v", err)
return ""
}
r := bytes.NewReader(w.Bytes())
img, format, err := image.Decode(r)
if err != nil {
t.Fatalf("cannot decode image: %v", err)
return ""
}
expectedSize := size.Mul(u)
rect := img.Bounds()
actualSize := rect.Size()
if !actualSize.Eq(expectedSize) {
t.Fatalf("wrong size expected %v, but actual %v", expectedSize, actualSize)
return ""
}
evalPixels(t, img, size, colors)
return format
}
// Converts the position of a detection in a feature image to a rectangle in the intensity image.
//
// Additional arguments are:
// the integer downsample rate of the feature transform,
// the margin which was added to the image before taking the feature transform,
// the rectangular region within the window which corresponds to the annotation.
func featPtToImRect(pt image.Point, rate int, margin feat.Margin, interior image.Rectangle) image.Rectangle {
return interior.Add(pt.Mul(rate)).Sub(margin.TopLeft())
}
func ExpandedNodeNew(getPositioner GetPositioner, userObj bh.NodeIf, nId bh.NodeIdIf) (ret *ExpandedNode) {
positioner := getPositioner(nId)
pos := positioner.Position()
path := nId.String()
config := DrawConfig{ColorInit(ColorOption(NormalExpandedNode)),
ColorInit(ColorOption(HighlightExpandedNode)),
ColorInit(ColorOption(SelectExpandedNode)),
ColorInit(ColorOption(BoxFrame)),
ColorInit(ColorOption(Text)),
image.Point{global.padX, global.padY}}
cconfig := ContainerConfig{expandedPortWidth, expandedPortHeight, 120, 80}
// Add children
var g bh.SignalGraphTypeIf
nt := userObj.ItsType()
for _, impl := range nt.Implementation() {
if impl.ImplementationType() == bh.NodeTypeGraph {
g = impl.Graph()
break
}
}
var children []ContainerChild
if g != nil {
empty := image.Point{}
first := image.Point{16, 32}
shift := image.Point{16, 16}
for i, n := range g.ProcessingNodes() {
var ch ContainerChild
var mode gr.PositionMode
if n.Expanded() {
mode = gr.PositionModeExpanded
} else {
mode = gr.PositionModeNormal
}
proxy := gr.PathModePositionerProxyNew(n)
proxy.SetActivePath(path)
proxy.SetActiveMode(mode)
log.Printf("ExpandedNodeNew TODO: position of child nodes. path=%s, mode=%v\n", path, mode)
chpos := proxy.Position()
if chpos == empty {
chpos = pos.Add(first.Add(shift.Mul(i)))
proxy.SetPosition(chpos)
}
id := freesp.NodeIdNew(nId, n.Name())
if n.Expanded() {
ch = ExpandedNodeNew(getPositioner, n, id)
} else {
ch = NodeNew(getPositioner, n, id)
}
children = append(children, ch)
}
}
ret = &ExpandedNode{ContainerInit(children, config, userObj, cconfig),
userObj, positioner, nil, nil}
ret.ContainerInit()
empty := image.Point{}
config = DrawConfig{ColorInit(ColorOption(InputPort)),
ColorInit(ColorOption(HighlightInPort)),
ColorInit(ColorOption(SelectInPort)),
ColorInit(ColorOption(BoxFrame)),
Color{},
image.Point{}}
for i, p := range userObj.InPorts() {
pos := p.ModePosition(gr.PositionModeExpanded)
if pos == empty {
pos = ret.CalcInPortPos(i)
}
positioner := gr.ModePositionerProxyNew(p, gr.PositionModeExpanded)
ret.AddPort(config, p, positioner)
}
config = DrawConfig{ColorInit(ColorOption(OutputPort)),
ColorInit(ColorOption(HighlightOutPort)),
ColorInit(ColorOption(SelectOutPort)),
ColorInit(ColorOption(BoxFrame)),
Color{},
image.Point{}}
for i, p := range userObj.OutPorts() {
pos := p.ModePosition(gr.PositionModeExpanded)
if pos == empty {
pos = ret.CalcOutPortPos(i)
}
positioner := gr.ModePositionerProxyNew(p, gr.PositionModeExpanded)
ret.AddPort(config, p, positioner)
}
for _, n := range g.ProcessingNodes() {
from, ok := ret.ChildByName(n.Name())
if !ok {
log.Printf("ExpandedNodeNew error: node %s not found\n", n.Name())
continue
}
for _, p := range n.OutPorts() {
fromId := from.OutPortIndex(p.Name())
for _, c := range p.Connections() {
to, ok := ret.ChildByName(c.Node().Name())
if ok {
toId := to.InPortIndex(c.Name())
ret.connections = append(ret.connections, ConnectionNew(from, to, fromId, toId))
} else {
portname, ok := c.Node().PortLink()
if !ok {
log.Printf("ExpandedNodeNew error: output node %s not linked\n", c.Node().Name())
continue
}
ownPort, ok := ret.OutPortByName(portname)
if !ok {
log.Printf("ExpandedNodeNew error: linked port %s of output node %s not found\n", portname, c.Node().Name())
continue
}
nodePort, ok := from.OutPortByName(p.Name())
if !ok {
log.Printf("ExpandedNodeNew error: port %s of output node %s not found\n", p.Name(), from.Name())
continue
}
ret.portconn = append(ret.portconn, PortConnectorNew(nodePort, ownPort))
}
}
}
}
for _, n := range g.InputNodes() {
for _, p := range n.OutPorts() {
fromlink, ok := p.Node().PortLink()
if !ok {
log.Printf("ExpandedNodeNew error: input node %s not linked\n", p.Node().Name())
continue
}
fromPort, ok := ret.InPortByName(fromlink)
if !ok {
log.Printf("ExpandedNodeNew error: linked port %s of input node %s not found\n", fromlink, n.Name())
continue
}
for _, c := range p.Connections() {
to, ok := ret.ChildByName(c.Node().Name())
if ok {
// TODO: connect with node
toPort, ok := to.InPortByName(c.Name())
if !ok {
log.Printf("ExpandedNodeNew error: port %s of node %s not found\n", c.Name(), to.Name())
continue
}
ret.portconn = append(ret.portconn, PortConnectorNew(fromPort, toPort))
} else {
tolink, ok := c.Node().PortLink()
if !ok {
log.Printf("ExpandedNodeNew error: output node %s not linked\n", c.Node().Name())
continue
}
toPort, ok := ret.OutPortByName(tolink)
if !ok {
log.Printf("ExpandedNodeNew error: linked port %s of output node %s not found\n", tolink, c.Node().Name())
continue
}
ret.portconn = append(ret.portconn, PortConnectorNew(fromPort, toPort))
}
}
}
}
ret.RegisterOnDraw(func(ctxt interface{}) {
expandedNodeOnDraw(ret, ctxt)
})
return
}
