// Read a magnetization state from .dump file.
func LoadFile(fname string) *data.Slice {
in, err := httpfs.Open(fname)
util.FatalErr(err)
var s *data.Slice
if path.Ext(fname) == ".dump" {
s, _, err = dump.Read(in)
} else {
s, _, err = oommf.Read(in)
}
util.FatalErr(err)
return s
}
func ImageShape(fname string) Shape {
r, err1 := httpfs.Open(fname)
CheckRecoverable(err1)
defer r.Close()
img, _, err2 := image.Decode(r)
CheckRecoverable(err2)
width := img.Bounds().Max.X
height := img.Bounds().Max.Y
// decode image into bool matrix for fast pixel lookup
inside := make([][]bool, height)
for iy := range inside {
inside[iy] = make([]bool, width)
}
for iy := 0; iy < height; iy++ {
for ix := 0; ix < width; ix++ {
r, g, b, a := img.At(ix, height-1-iy).RGBA()
if a > 128 && r+g+b < (0xFFFF*3)/2 {
inside[iy][ix] = true
}
}
}
// stretch the image onto the gridsize
c := Mesh().CellSize()
cx, cy := c[X], c[Y]
N := Mesh().Size()
nx, ny := float64(N[X]), float64(N[Y])
w, h := float64(width), float64(height)
return func(x, y, z float64) bool {
ix := int((w/nx)*(x/cx) + 0.5*w)
iy := int((h/ny)*(y/cy) + 0.5*h)
if ix < 0 || ix >= width || iy < 0 || iy >= height {
return false
} else {
return inside[iy][ix]
}
}
}
func doFile(infname string, outp output) {
// determine output file
outfname := util.NoExt(infname) + outp.Ext
if *flag_dir != "" {
outfname = *flag_dir + "/" + path.Base(outfname)
}
msg := infname + "\t-> " + outfname
defer func() { log.Println(msg) }()
if infname == outfname {
msg = fail(msg, "input and output file are the same")
return
}
defer func() {
if err := recover(); err != nil {
msg = fail(msg, err)
os.Remove(outfname)
}
}()
if !(strings.HasPrefix(infname, "http://") || strings.HasPrefix(outfname, "http://")) {
inStat, errS := os.Stat(infname)
if errS != nil {
panic(errS)
}
outStat, errO := os.Stat(outfname)
if errO == nil && outStat.ModTime().Sub(inStat.ModTime()) > 0 {
msg = "[skip] " + msg + ": skipped based on time stamps"
skipped.Add(1)
return
}
}
var slice *data.Slice
var info data.Meta
var err error
in, errI := httpfs.Open(infname)
if errI != nil {
msg = fail(msg, errI)
return
}
defer in.Close()
switch path.Ext(infname) {
default:
msg = fail(msg, ": skipping unsupported type: "+path.Ext(infname))
return
case ".ovf", ".omf", ".ovf2":
slice, info, err = oommf.Read(in)
case ".dump":
slice, info, err = dump.Read(in)
}
if err != nil {
msg = fail(msg, err)
return
}
out, err := httpfs.Create(outfname)
if err != nil {
msg = fail(msg, err)
return
}
defer out.Close()
preprocess(slice)
outp.Convert(slice, info, panicWriter{out})
succeeded.Add(1)
msg = "[ ok ] " + msg
}
