Improve documentation, code formatting

 - removed manic blog post readme
 - stopped exporting implementation details no one cares about
 - miscellaneous code clean up
 - created Color type for more reasonable formatting logic
 - moved command-line util to cmd/vibrant
 - transformed demo app from a spaghetti nightmare into something decent

Author: dayvonjersen

.gitignore

@@ -1,6 +1,3 @@
 *.sw*
 *.jpg
 *.png
-iris/*
-cmd/vibrant
-cmd/cmd

README.md

@@ -1,100 +1,102 @@
 # vibrant
 
-go port of the [Android awesome Palette class](https://android.googlesource.com/platform/frameworks/support/+/b14fc7c/v7/palette/src/android/support/v7/graphics/)
+[![godoc reference](https://godoc.org/github.com/generaltso/vibrant?status.png)](https://godoc.org/github.com/generaltso/vibrant)
 
-which I translated from this beautifully cleaned up version:
-https://github.com/Infinity/Iris
 
-and was first made aware of by [this Google I/O 2014 presentation](https://www.youtube.com/watch?v=ctzWKRlTYHQ?t=451)
+Extract prominent colors from images. Go port of the [Android awesome Palette class](https://android.googlesource.com/platform/frameworks/support/+/b14fc7c/v7/palette/src/android/support/v7/graphics/) aka [Vibrant.js](https://github.com/jariz/vibrant.js).
 
-and of course
-https://github.com/jariz/vibrant.js
+![screenshot of app.go](https://u.teknik.io/Rv3r3.png)
 
-and last but not least
-https://github.com/akfish/node-vibrant
+# install
 
-## Why
+```
+go get github.com/generaltso/vibrant
+```
+
+# usage
 
-I was dissatisfied with the performance of the above JavaScript ports. One day, I mocked up an HTML thumbnail view gallery thing and wanted to use "Vibrancy" to decorate the buttons, links, titles, etc. The page had about 25 wallpaper images I used just as placeholders and using Vibrant.js brought my browser to its knees.
+```go
+// example: create css stylesheet from image file
+checkErr := func(err error) { if err != nil { panic(err) } }
 
-Yes, I could have just thumbnailed the wallpapers and carried on like a normal person, but this act of stupidity got me thinking: why do this calculation in the browser? If it kills my browser like this, imagine what it must do to mobiles. And it's not like the images are dynamic (in my use case, anyway). They're dynamic in the sense that users upload them but once they're there, they don't change and neither does their palette.
+f, err := os.Open("some_image.jpg")
+checkErr(err)
+defer f.Close()
 
-So why not do it server-side and cache the result? As a CSS file, which I can then use with `<style scoped>` e.g.:
-```HTML
-<section class="card">
-   <style scoped>@import "image1-vibrant.css";</style>
-   <h1 class="darkvibrant">~Fancy Title~</h1>
-   <div class="card-border muted">
-       <img src="image1-thumb.jpg">
-   </div>
-   <div class="card-caption darkmuted">
-       <button class="vibrant">Call to action!</button>
-   </div>
-</section>
+img, _, err := image.Decode(f)
+checkErr(err)
+
+palette, err := vibrant.NewPaletteFromImage(img)
+checkErr(err)
+
+for name, swatch := range palette.ExtractAwesome() {
+  fmt.Printf("/* %s (population: %d) */\n%s\n\n", name, swatch.Population, swatch)
+}
 ```
 
+###### output:
+```css
+/* LightMuted (population: 253) */
+.lightmuted{background-color:#cbc0a2;color:#000000;}
 
-It's probably not a good idea to over-do it like that with the colors, but the point is that you *can* do it in the first place.
+/* DarkMuted (population: 11069) */
+.darkmuted{background-color:#5b553f;color:#ffffff;}
 
-This approach also allows for graceful fallback to a default palette set
+/* Vibrant (population: 108) */
+.vibrant{background-color:#dfd013;color:#000000;}
 
-Perhaps I should stop trying to words **here is an example of scoped css**, view source until it makes sense:
-http://var.abl.cl/scoped-css
+/* LightVibrant (population: 87) */
+.lightvibrant{background-color:#f4ed7d;color:#000000;}
+
+/* DarkVibrant (population: 2932) */
+.darkvibrant{background-color:#917606;color:#ffffff;}
+
+/* Muted (population: 4098) */
+.muted{background-color:#a58850;color:#000000;}
 
-## Usage
-```bash
-$ go get github.com/generaltso/vibrant
 ```
 
-```go
-package main
-
-import (
-	"fmt"
-	"image"
-    _ "image/jpeg"
-	"log"
-	"os"
-)
-
-import "github.com/generaltso/vibrant"
-
-func main() {
-	file, err := os.Open("some_image.jpg")
-	if err != nil {
-		log.Fatalln(err)
-	}
-	img, _, err := image.Decode(file)
-	if err != nil {
-		log.Fatalln(err)
-	}
-	palette, err := vibrant.NewPaletteFromImage(img)
-	if err != nil {
-		log.Fatalln(err)
-	}
-	for name, swatch := range palette.ExtractAwesome() {
-		fmt.Printf("name: %s, color: %s, population: %d\n", name /* or swatch.Name */, swatch.RGBHex(), swatch.Population)
-	}
-}
+See [godoc reference](https://godoc.org/github.com/generaltso/vibrant) for full API.
+
+# bonus round
+
+## reference implementation/command line tool
+```
+go get github.com/generaltso/vibrant/cmd/vibrant
 ```
 
-There is also a command-line tool in vibrant/:
-```bash
-$ cd vibrant && go install
-$ vibrant some_image.png
 ```
-(it prints CSS to stdout)
+usage: vibrant [options] file
+
+options:
+  -compress
+    	Strip whitespace from output.
+  -css
+    	Output results in CSS.
+  -json
+    	Output results in JSON.
+  -lowercase
+    	Use lowercase only for all output. (default true)
+  -rgb
+    	Output RGB instead of HTML hex, e.g. #ffffff.
+```
+
+## webapp
 
-And there is a simple demo application which is a little more visual:
-```bash
-$ cd demo && go run app.go
-Listening on 0.0.0.0:8080...
 ```
-![screenshot of app.go](https://u.teknik.io/G3qoka.png)
+go get github.com/generaltso/vibrant
+cd $GOPATH/github.com/generaltso/vibrant
+go run webapp.go
+# open http://localhost:8080/ in a browser
+```
 
 
-**This API and the tools provided are a work-in-progress proof-of-concept and certainly could use improvement, better naming, etc.**
+# thanks
 
-Comments, feedback and pull requests are welcome!
-[email me](mailto:[email protected])
-[find this project on github](https://github.com/generaltso/vibrant)
+https://github.com/Infinity/Iris
+
+[This Google I/O 2014 presentation](https://www.youtube.com/watch?v=ctzWKRlTYHQ?t=451)
+
+https://github.com/jariz/vibrant.js
+
+https://github.com/akfish/node-vibrant

bitmap.go

@@ -1,32 +1,35 @@
 package vibrant
 
-import "github.com/nfnt/resize"
-import "image"
-import "image/color"
-import "math"
+import (
+	"image"
+	"image/color"
+	"math"
 
-// type Bitmap is a simple wrapper for an image.Image
-type Bitmap struct {
+	"github.com/nfnt/resize"
+)
+
+// type bitmap is a simple wrapper for an image.Image
+type bitmap struct {
 	Width  int
 	Height int
 	Source image.Image
 }
 
-func NewBitmap(input image.Image) *Bitmap {
+func newBitmap(input image.Image) *bitmap {
 	bounds := input.Bounds()
-	return &Bitmap{bounds.Dx(), bounds.Dy(), input}
+	return &bitmap{bounds.Dx(), bounds.Dy(), input}
 }
 
-// Scales input image.Image by ratio using github.com/nfnt/resize
-func NewScaledBitmap(input image.Image, ratio float64) *Bitmap {
+// Scales input image.Image by aspect ratio using https://github.com/nfnt/resize
+func newScaledBitmap(input image.Image, ratio float64) *bitmap {
 	bounds := input.Bounds()
 	w := math.Ceil(float64(bounds.Dx()) * ratio)
 	h := math.Ceil(float64(bounds.Dy()) * ratio)
-	return &Bitmap{int(w), int(h), resize.Resize(uint(w), uint(h), input, resize.Bilinear)}
+	return &bitmap{int(w), int(h), resize.Resize(uint(w), uint(h), input, resize.Bilinear)}
 }
 
-// Returns all of the pixels of this Bitmap.Source as a 1D array of color.Color's
-func (b *Bitmap) Pixels() []color.Color {
+// Returns all of the pixels of this bitmap.Source as a 1D array of image/color.Color
+func (b *bitmap) Pixels() []color.Color {
 	c := make([]color.Color, 0)
 	for y := 0; y < b.Height; y++ {
 		for x := 0; x < b.Width; x++ {

vibrant/vibrant.go cmd/vibrant/vibrant.go

@@ -15,11 +15,13 @@ import (
 	"github.com/generaltso/vibrant"
 )
 
-var output_json bool
-var output_css bool
-var output_compress bool
-var output_lowercase bool
-var output_rgb bool
+var (
+	output_json      bool
+	output_css       bool
+	output_compress  bool
+	output_lowercase bool
+	output_rgb       bool
+)
 
 func usage() {
 	println("usage: vibrant [options] file")
@@ -82,10 +84,10 @@ func print_json(palette vibrant.Palette) {
 	out := map[string]interface{}{}
 	for name, sw := range palette.ExtractAwesome() {
 		if output_rgb {
-			r, g, b := sw.RGB()
+			r, g, b := sw.Color.RGB()
 			out[name] = map[string]int{"r": r, "g": g, "b": b}
 		} else {
-			out[name] = swatch{sw.RGBHex(), sw.TitleTextColor()}
+			out[name] = swatch{sw.Color.RGBHex(), sw.Color.TitleTextColor().RGBHex()}
 		}
 	}
 	var b []byte
@@ -104,14 +106,6 @@ func print_json(palette vibrant.Palette) {
 	fmt.Println(str)
 }
 
-func textcolor(sw *vibrant.Swatch) (r, g, b int) {
-	c := vibrant.TextColor(sw.Color, vibrant.MIN_CONTRAST_TITLE_TEXT)
-	r = c >> 16 & 0xff
-	g = c >> 8 & 0xff
-	b = c & 0xff
-	return
-}
-
 func rgb(r ...int) string {
 	return fmt.Sprintf("rgb(%d,%d,%d)", r[0], r[1], r[2])
 }
@@ -131,11 +125,11 @@ func print_css(palette vibrant.Palette) {
 		var bgcolor string
 		var fgcolor string
 		if output_rgb {
-			bgcolor = rgb(sw.RGB())
-			fgcolor = rgb(textcolor(sw))
+			bgcolor = rgb(sw.Color.RGB())
+			fgcolor = rgb(sw.Color.TitleTextColor().RGB())
 		} else {
-			bgcolor = sw.RGBHex()
-			fgcolor = sw.TitleTextColor()
+			bgcolor = sw.Color.RGBHex()
+			fgcolor = sw.Color.TitleTextColor().RGBHex()
 		}
 		if output_lowercase {
 			name = strings.ToLower(name)
@@ -162,6 +156,6 @@ func shorthex(hex string) string {
 
 func print_plain(palette vibrant.Palette) {
 	for name, sw := range palette.ExtractAwesome() {
-		fmt.Printf("% 12s: %s, population: %d\n", name, sw.RGBHex(), sw.Population)
+		fmt.Printf("% 12s: %s, population: %d\n", name, sw.Color.RGBHex(), sw.Population)
 	}
 }