func NewImage(path string) (*Image, error) {
f, ferr := os.Open(path)
if ferr != nil {
fmt.Fprintf(os.Stderr, "%v\n", ferr)
return nil, fmt.Errorf("Could not open image %v", ferr)
}
defer f.Close()
imConf, _, err := image.DecodeConfig(f)
if err != nil {
return nil, fmt.Errorf("Could not decode image", err)
}
im := Image{}
im.Path = path
pathArr := strings.Split(path, "/")
im.Url = "/inc/" + pathArr[len(pathArr)-1]
fmt.Println(im.Url)
size := geom.Rect{}
size.Min = geom.Coord{X: 0, Y: 0}
size.Max = geom.Coord{X: float64(imConf.Width), Y: float64(imConf.Height)}
im.Size = size
return &im, nil
}
func (rs *RectangleStore) Remove(box *geom.Rect, coord *geom.Coord, i interface{}) error {
x := coord.X
y := coord.Y
xPrime := x + box.Width()
yPrime := y + box.Height()
startX := int(x) / rs.Width
endX := int(xPrime) / rs.Width
startY := int(y) / rs.Height
endY := int(yPrime) / rs.Height
for ii := startX; ii < endX; ii++ {
for jj := startY; jj < endY; jj++ {
if ii < 0 || jj < 0 || ii > len(rs.Values) || jj > len(rs.Values[0]) {
continue
}
for kk, toDel := range rs.Values[ii][jj] {
if toDel == i {
fmt.Println("removed")
copy(rs.Values[ii][jj][kk:], rs.Values[ii][jj][kk+1:])
rs.Values[ii][jj] = rs.Values[ii][jj][:len(rs.Values[ii][jj])-1]
}
}
}
}
return nil
}
func (me *Tree) RemoveInside(bounds geom.Rect, collection map[Item]bool) {
if !geom.RectsIntersect(bounds, me.UpperBounds) {
return
}
if me.BigElements != nil {
for elem := range me.BigElements {
if bounds.ContainsRect(elem.Bounds()) {
delete(me.BigElements, elem)
if collection != nil {
collection[elem] = true
}
}
}
}
if me.Elements != nil {
for elem := range me.Elements {
if bounds.ContainsRect(elem.Bounds()) {
delete(me.Elements, elem)
if collection != nil {
collection[elem] = true
}
}
}
}
for _, t := range me.Subtrees {
if t == nil {
continue
}
t.RemoveInside(bounds, collection)
}
return
}
func (rs *RectangleStore) Add(box *geom.Rect, coord *geom.Coord, i interface{}) error {
x := coord.X
y := coord.Y
xPrime := x + box.Width()
yPrime := y + box.Height()
fmt.Println(x, y)
fmt.Println(xPrime, yPrime)
startX := int(x) / rs.Width
endX := int(xPrime) / rs.Width
startY := int(y) / rs.Height
endY := int(yPrime) / rs.Height
for ii := startX; ii <= endX; ii++ {
for jj := startY; jj <= endY; jj++ {
if ii < 0 || jj < 0 || ii >= len(rs.Values) || jj >= len(rs.Values[0]) {
continue
}
// fmt.Printf("%v, %v :: %v, %v\n", ii, jj, len(rs.Values), len(rs.Values[ii]))
rs.Values[ii][jj] = append(rs.Values[ii][jj], i)
}
}
return nil
}
func (rs *RectangleStore) Inside(box *geom.Rect, coord *geom.Coord) []interface{} {
var i []interface{}
x := coord.X
y := coord.Y
xPrime := x + box.Width()
yPrime := y + box.Height()
startX := int(x) / rs.Width
endX := int(xPrime) / rs.Width
startY := int(y) / rs.Height
endY := int(yPrime) / rs.Height
dupMap := make(map[interface{}]bool)
for ii := startX; ii <= endX; ii++ {
for jj := startY; jj < endY; jj++ {
//fmt.Printf("Index %v, %v\n", ii, jj)
if ii < 0 || jj < 0 || ii >= len(rs.Values) || jj >= len(rs.Values[0]) {
continue
}
for _, val := range rs.Values[ii][jj] {
if val != nil && !dupMap[val] {
dupMap[val] = true
i = append(i, val)
}
}
}
}
return i
}
func (self *Image) ConstructCells(number int, max geom.Coord) (err error) {
size := geom.Rect{}
size.Min = geom.Coord{X: 0, Y: 0}
size.Max = max
self.CellNumber = number
self.CellSize = size
return
}
func NewRectangleStore(box *geom.Rect, innerBox *geom.Rect) *RectangleStore {
outerWidth := box.Width()
outerHeight := box.Height()
innerWidth := innerBox.Width()
innerHeight := innerBox.Height()
x := math.Floor(outerWidth / innerWidth)
y := math.Floor(outerHeight / innerHeight)
rs := &RectangleStore{
Values: make([][][]interface{}, int(x)),
Width: int(innerWidth),
Height: int(innerHeight),
}
for ii, _ := range rs.Values {
rs.Values[ii] = make([][]interface{}, int(y))
for jj, _ := range rs.Values[ii] {
rs.Values[ii][jj] = make([]interface{}, InitialSize)
}
}
fmt.Printf("rectangles: %+v, %+v \n", len(rs.Values), len(rs.Values[0]))
fmt.Printf("box: %v\n", box)
fmt.Printf("inbox: %v\n", innerBox)
return rs
}
func (me *Tree) IsBig(bounds geom.Rect) bool {
return bounds.Width() >= me.cfg.SplitSizeRatio*me.UpperBounds.Width() ||
bounds.Height() >= me.cfg.SplitSizeRatio*me.UpperBounds.Height()
}
func (g *Grid) regrid() {
g.reflex()
_, minXs, maxXs := g.hflex.constrain(g.Size.X)
_, minYs, maxYs := g.vflex.constrain(g.Size.Y)
for child, csh := range g.ChildrenHints {
bd := g.childrenBlockData[child]
gridBounds := geom.Rect{
Min: geom.Coord{
X: minXs[bd.GridX],
Y: minYs[bd.GridY],
},
Max: geom.Coord{
X: maxXs[bd.GridX+bd.ExtraX],
Y: maxYs[bd.GridY+bd.ExtraY],
},
}
gridSizeX, gridSizeY := gridBounds.Size()
if gridSizeX > csh.MaxSize.X {
diff := gridSizeX - csh.MaxSize.X
if bd.AnchorX&AnchorMin != 0 && bd.AnchorX&AnchorMax != 0 {
gridBounds.Min.X += diff / 2
gridBounds.Max.X -= diff / 2
} else if bd.AnchorX&AnchorMin != 0 {
gridBounds.Max.X -= diff
} else if bd.AnchorX&AnchorMax != 0 {
gridBounds.Min.X += diff
}
}
if gridSizeY > csh.MaxSize.Y {
diff := gridSizeY - csh.MaxSize.Y
if bd.AnchorY&AnchorMin == 0 && bd.AnchorY&AnchorMax == 0 {
gridBounds.Min.Y += diff / 2
gridBounds.Max.Y -= diff / 2
} else if bd.AnchorY&AnchorMin != 0 {
gridBounds.Max.Y -= diff
} else if bd.AnchorY&AnchorMax != 0 {
gridBounds.Min.Y += diff
}
}
gridSizeX, gridSizeY = gridBounds.Size()
if gridSizeX > csh.PreferredSize.X {
diff := gridSizeX - csh.PreferredSize.X
if bd.AnchorX&AnchorMin != 0 && bd.AnchorX&AnchorMax != 0 {
gridBounds.Min.X += diff / 2
gridBounds.Max.X -= diff / 2
} else if bd.AnchorX&AnchorMin != 0 {
gridBounds.Max.X -= diff
} else if bd.AnchorX&AnchorMax != 0 {
gridBounds.Min.X += diff
}
}
if gridSizeY > csh.PreferredSize.Y {
diff := gridSizeY - csh.PreferredSize.Y
if bd.AnchorY&AnchorMin == 0 && bd.AnchorY&AnchorMax == 0 {
gridBounds.Min.Y += diff / 2
gridBounds.Max.Y -= diff / 2
} else if bd.AnchorY&AnchorMin != 0 {
gridBounds.Max.Y -= diff
} else if bd.AnchorY&AnchorMax != 0 {
gridBounds.Min.Y += diff
}
}
g.ChildrenBounds[child] = gridBounds
gridSizeX, gridSizeY = gridBounds.Size()
child.UserEventsIn <- uik.ResizeEvent{
Size: geom.Coord{gridSizeX, gridSizeY},
}
}
g.Invalidate()
}
func (g *GridEngine) GetLayout(size geom.Coord) (layout Layout) {
layout = make(Layout)
_, minXs, maxXs := g.hflex.constrain(size.X)
_, minYs, maxYs := g.vflex.constrain(size.Y)
// if g.Block.ID == 2 {
// uik.Report("regrid", g.Block.ID, g.Size, whs, wvs)
// }
for child, csh := range g.childrenHints {
bd := g.childrenGridComponents[child]
gridBounds := geom.Rect{
Min: geom.Coord{
X: minXs[bd.GridX],
Y: minYs[bd.GridY],
},
Max: geom.Coord{
X: maxXs[bd.GridX+bd.ExtraX],
Y: maxYs[bd.GridY+bd.ExtraY],
},
}
gridSizeX, gridSizeY := gridBounds.Size()
if gridSizeX > csh.MaxSize.X {
diff := gridSizeX - csh.MaxSize.X
if !bd.AnchorLeft && !bd.AnchorRight {
gridBounds.Min.X += diff / 2
gridBounds.Max.X -= diff / 2
}
if bd.AnchorLeft && !bd.AnchorRight {
gridBounds.Max.X -= diff
}
if !bd.AnchorLeft && bd.AnchorRight {
gridBounds.Min.X += diff
}
}
if gridSizeY > csh.MaxSize.Y {
diff := gridSizeY - csh.MaxSize.Y
if !bd.AnchorTop && !bd.AnchorBottom {
gridBounds.Min.Y += diff / 2
gridBounds.Max.Y -= diff / 2
}
if bd.AnchorTop && !bd.AnchorBottom {
gridBounds.Max.Y -= diff
}
if !bd.AnchorTop && bd.AnchorBottom {
gridBounds.Min.Y += diff
}
}
gridSizeX, gridSizeY = gridBounds.Size()
if gridSizeX > csh.PreferredSize.X {
diff := gridSizeX - csh.PreferredSize.X
if !bd.AnchorLeft && !bd.AnchorRight {
gridBounds.Min.X += diff / 2
gridBounds.Max.X -= diff / 2
}
if bd.AnchorLeft && !bd.AnchorRight {
gridBounds.Max.X -= diff
}
if !bd.AnchorLeft && bd.AnchorRight {
gridBounds.Min.X += diff
}
}
if gridSizeY > csh.PreferredSize.Y {
diff := gridSizeY - csh.PreferredSize.Y
if !bd.AnchorTop && !bd.AnchorBottom {
gridBounds.Min.Y += diff / 2
gridBounds.Max.Y -= diff / 2
}
if bd.AnchorTop && !bd.AnchorBottom {
gridBounds.Max.Y -= diff
}
if !bd.AnchorTop && bd.AnchorBottom {
gridBounds.Min.Y += diff
}
}
layout[child] = gridBounds
}
return
}