func main() {
filepath.Walk("../../../images/", func(path string, info os.FileInfo, err error) error {
if info.IsDir() {
return nil
}
fmt.Println(path)
f, err := os.Open(path)
if err != nil {
log.Fatal(err)
}
defer f.Close()
// Optionally register camera makenote data parsing - currently Nikon and
// Canon are supported.
exif.RegisterParsers(mknote.All...)
x, err := exif.Decode(f)
if err != nil {
log.Fatal(err)
}
// Two convenience functions exist for date/time taken and GPS coords:
tm, _ := x.DateTime()
fmt.Println("Taken: ", tm)
lat, long, _ := x.LatLong()
fmt.Println("lat, long: ", lat, ", ", long)
return nil
})
}
// Load initializes a Photograph from a file.
func (p *Photograph) Load(fileName string) error {
p.OriginalFileName = fileName
fd, err := os.Open(fileName)
if err != nil {
logging.Log.Error("%v", err)
return err
}
defer fd.Close()
exif.RegisterParsers(mknote.All...)
exifData, err := exif.Decode(fd)
if err != nil {
logging.Log.Error("%v", err)
return err
}
err = exifData.Walk(p)
if err != nil {
logging.Log.Error("%v", err)
return err
}
offset, err := fd.Seek(0, 0)
if err != nil {
logging.Log.Error("%v", err)
return err
}
logging.Log.Debug("offset=%v", offset)
p.Data, err = ioutil.ReadAll(fd)
if err != nil {
logging.Log.Error("%v", err)
return err
}
return nil
}
func main() {
fname := "01.jpg"
f, err := os.Open(fname)
if err != nil {
log.Fatal(err)
}
// Optionally register camera makenote data parsing - currently Nikon and
// Canon are supported.
exif.RegisterParsers(mknote.All...)
x, err := exif.Decode(f)
if err != nil {
log.Fatal(err)
}
camModel, _ := x.Get(exif.Model) // normally, don't ignore errors!
fmt.Println(camModel.StringVal())
focal, _ := x.Get(exif.FocalLength)
numer, denom, _ := focal.Rat2(0) // retrieve first (only) rat. value
fmt.Printf("%v/%v", numer, denom)
// Two convenience functions exist for date/time taken and GPS coords:
tm, _ := x.DateTime()
fmt.Println("Taken: ", tm)
lat, long, _ := x.LatLong()
fmt.Println("lat, long: ", lat, ", ", long)
}
func main() {
flag.Parse()
roots := flag.Args()
exif.RegisterParsers(mknote.All...)
// root := flag.Arg(0)
if len(roots) == 0 {
fmt.Printf("Root folder(s) not specified.")
os.Exit(1)
}
for _, root := range roots {
if _, err := os.Stat(root); os.IsNotExist(err) {
fmt.Printf("Root folder not found: %s\n", root)
continue
}
err := fswalker.WalkImages(root, visit)
if err != nil {
fmt.Printf("WalkImages(%s) returned %v\n", root, err)
}
// the bounded walker
// if err := fswalker.MD5All(root); err != nil {
// fmt.Printf("MD5 error:%v\n", err)
// }
}
}
func home(res http.ResponseWriter, req *http.Request) {
type Photo struct {
PhotoPath string
Lat float64
Long float64
}
var model struct {
Photos []Photo
LoggedIn bool
}
session, _ := store.Get(req, "session-name")
_, model.LoggedIn = session.Values["loggedin"]
filepath.Walk("assets/imgs", func(path string, info os.FileInfo, err error) error {
if !info.IsDir() {
fmt.Println("WALKING", path)
var currentPhoto Photo
currentPhoto.PhotoPath = path
f, err := os.Open(path)
if err != nil {
log.Fatal(err)
}
exif.RegisterParsers(mknote.All...)
x, err := exif.Decode(f)
if err != nil {
log.Println("no info")
return nil
}
currentPhoto.Lat, currentPhoto.Long, _ = x.LatLong()
fmt.Println("lat, long: ", currentPhoto.Lat, ", ", currentPhoto.Long)
model.Photos = append(model.Photos, currentPhoto)
}
return nil
})
err := tpl.ExecuteTemplate(res, "index.gohtml", model)
if err != nil {
http.Error(res, err.Error(), 500)
}
}
func main() {
flag.Parse()
fnames := flag.Args()
if *mnote {
exif.RegisterParsers(mknote.All...)
}
for _, name := range fnames {
f, err := os.Open(name)
if err != nil {
log.Printf("err on %v: %v", name, err)
continue
}
x, err := exif.Decode(f)
if err != nil {
log.Printf("err on %v: %v", name, err)
continue
}
if *thumb {
data, err := x.JpegThumbnail()
if err != nil {
log.Fatal("no thumbnail present")
}
if _, err := os.Stdout.Write(data); err != nil {
log.Fatal(err)
}
return
}
fmt.Printf("\n---- Image '%v' ----\n", name)
x.Walk(Walker{})
if x.Comment != "" {
fmt.Printf(" %v: %v\n", "Comment", x.Comment)
}
}
}
// Get the EXIF Data from the JPEG
func (img *ImageMeta) GetExif() (*ExifHandler, bool) {
// Ensure that this is a JPEG
if !img.IsJPEG() {
return nil, false
}
if f, err := os.Open(img.Path); err == nil {
defer f.Close()
exif.RegisterParsers(mknote.All...)
walker := new(ExifHandler)
walker.tags = make(map[string]string)
if x, err := exif.Decode(f); err == nil {
walker.exif = x
x.Walk(walker)
return walker, true
}
}
return nil, false
}
func main() {
fmt.Println("Hello, world")
fname := "P1070332.JPG"
rname := "P1070332_rotate.JPG"
sname := "P1070332_small.JPG"
f, err := os.Open(fname)
if err != nil {
log.Fatal(err)
}
defer f.Close()
// Optionally register camera makenote data parsing - currently Nikon and
// Canon are supported.
exif.RegisterParsers(mknote.All...)
x, err := exif.Decode(f)
if err != nil {
log.Fatal(err)
}
// Get Orientation
orientation, err := x.Get(exif.Orientation)
if err != nil {
fmt.Println(exif.Model, " not fround")
return
}
fmt.Println("Orientation", orientation.String())
// Rotate
var rotateImage *image.NRGBA
openImage, err := imaging.Open(fname)
if err != nil {
fmt.Println(err)
return
}
switch orientation.String() {
case "1":
// Do nothing
case "2":
rotateImage = imaging.FlipH(openImage)
case "3":
rotateImage = imaging.Rotate180(openImage)
case "4":
rotateImage = imaging.FlipV(openImage)
case "5":
rotateImage = imaging.Transverse(openImage)
case "6":
rotateImage = imaging.Rotate270(openImage)
case "7":
rotateImage = imaging.Transpose(openImage)
case "8":
rotateImage = imaging.Rotate90(openImage)
}
err = imaging.Save(rotateImage, rname)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(rname, " saved")
// Small
var smallImage *image.NRGBA
if rotateImage.Rect.Dx() > rotateImage.Rect.Dy() {
smallImage = imaging.Resize(rotateImage, 1920, 0, imaging.Lanczos)
} else {
smallImage = imaging.Resize(rotateImage, 0, 1920, imaging.Lanczos)
}
err = imaging.Save(smallImage, sname)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(sname, " saved")
// Use jpeg.Encode() to write to a file
// https://github.com/disintegration/imaging/blob/master/helpers.go#L79
// func Encode(w io.Writer, m image.Image, o *Options) error
// https://golang.org/pkg/image/jpeg/
}
func home(res http.ResponseWriter, req *http.Request) {
type Photo struct {
PhotoPath string
Lat float64
Long float64
}
var model struct {
Photos []Photo
LoggedIn bool
}
// session
session, _ := store.Get(req, "session-name")
_, model.LoggedIn = session.Values["loggedin"]
filepath.Walk("assets/imgs", func(path string, info os.FileInfo, err error) error {
if !info.IsDir() {
fmt.Println("WALKING", path)
var currentPhoto Photo
currentPhoto.PhotoPath = path
// photo lat long
// fname := "assets/imgs/us.jpg"
f, err := os.Open(path)
if err != nil {
log.Fatal(err)
}
// Optionally register camera makenote data parsing - currently Nikon and
// Canon are supported.
exif.RegisterParsers(mknote.All...)
x, err := exif.Decode(f)
if err != nil {
log.Println("no info")
return nil
}
// camModel, _ := x.Get(exif.Model) // normally, don't ignore errors!
// fmt.Println(camModel.StringVal())
//
// focal, _ := x.Get(exif.FocalLength)
// numer, denom, _ := focal.Rat2(0) // retrieve first (only) rat. value
// fmt.Printf("%v/%v", numer, denom)
//
// // Two convenience functions exist for date/time taken and GPS coords:
// tm, _ := x.DateTime()
// fmt.Println("Taken: ", tm)
currentPhoto.Lat, currentPhoto.Long, _ = x.LatLong()
fmt.Println("lat, long: ", currentPhoto.Lat, ", ", currentPhoto.Long)
model.Photos = append(model.Photos, currentPhoto)
}
return nil
})
err := tpl.ExecuteTemplate(res, "index.gohtml", model)
if err != nil {
http.Error(res, err.Error(), 500)
}
}
