func runGreyscale(cmd *hadfield.Command, args []string) {
i, data := utils.ReadStdin()
if greyscaleAverage {
i = greyscale.Average(i)
} else if greyscaleLightness {
i = greyscale.Lightness(i)
} else if greyscaleLuminosity {
i = greyscale.Luminosity(i)
} else if greyscaleMaximal {
i = greyscale.Maximal(i)
} else if greyscaleMinimal {
i = greyscale.Minimal(i)
} else if greyscaleRed {
i = greyscale.Red(i)
} else if greyscaleGreen {
i = greyscale.Green(i)
} else if greyscaleBlue {
i = greyscale.Blue(i)
} else {
i = greyscale.Greyscale(i)
}
utils.WriteStdout(i, data)
}
func runBlur(cmd *hadfield.Command, args []string) {
var style blur.Style
switch blurStyle {
case "clamp":
style = blur.CLAMP
case "ignore":
style = blur.IGNORE
case "wrap":
style = blur.WRAP
default:
utils.Warn("--style must be one of 'clamp', 'ignore' or 'wrap'")
os.Exit(2)
}
i, data := utils.ReadStdin()
if blurBox {
i = blur.Box(i, blurRadius, style)
} else {
i = blur.Gaussian(i, blurRadius, blurGaussian, style)
}
utils.WriteStdout(i, data)
}
func runCrop(cmd *hadfield.Command, args []string) {
i, data := utils.ReadStdin()
direction := utils.Centre
if cropTop {
direction = utils.Top
} else if cropTopRight {
direction = utils.TopRight
} else if cropRight {
direction = utils.Right
} else if cropBottomRight {
direction = utils.BottomRight
} else if cropBottom {
direction = utils.Bottom
} else if cropBottomLeft {
direction = utils.BottomLeft
} else if cropLeft {
direction = utils.Left
} else if cropTopLeft {
direction = utils.TopLeft
}
if cropCircle {
i = crop.Circle(i, cropSize, direction)
} else if cropTriangle {
i = crop.Triangle(i, cropSize, direction)
} else {
i = crop.Square(i, cropSize, direction)
}
utils.WriteStdout(i, data)
}
func main() {
var (
long = flag.Bool("long", false, "")
short = flag.Bool("short", false, "")
usage = flag.Bool("usage", false, "")
)
os.Args = utils.GetOutput(os.Args)
flag.Parse()
if *long {
fmt.Println(
" Applies a simple lomo effect to the image, boosting its saturation and\n" +
" composing with a black edged mask.",
)
} else if *short {
fmt.Println("applies a simple lomo effect to the image")
} else if *usage {
fmt.Println("lomo [options]")
} else {
img, data := utils.ReadStdin()
// http://the.taoofmac.com/space/blog/2005/08/23/2359
img = contrast.Adjust(img, 1.2)
img = channel.Adjust(img, utils.Multiplier(1.2), channel.Saturation)
img = blend.Multiply(img, maskFor(img))
utils.WriteStdout(img, data)
}
}
func runHxl(cmd *hadfield.Command, args []string) {
i, data := utils.ReadStdin()
if hxlCols > 0 {
hxlWidth = utils.SizeForCols(i, hxlCols).W
}
i = pixelate.Hxl(i, hxlWidth)
utils.WriteStdout(i, data)
}
func runVxl(cmd *hadfield.Command, args []string) {
i, data := utils.ReadStdin()
if vxlRows > 0 {
vxlHeight = utils.SizeForRows(i, vxlRows).H
}
i = pixelate.Vxl(i, vxlHeight, vxlFlip, vxlTop, vxlLeft, vxlRight)
utils.WriteStdout(i, data)
}
func runSharpen(cmd *hadfield.Command, args []string) {
i, data := utils.ReadStdin()
if sharpenUnsharp {
i = sharpen.UnsharpMask(i, sharpenRadius, sharpenSigma, sharpenAmount, sharpenThreshold)
} else {
i = sharpen.Sharpen(i, sharpenRadius, sharpenSigma)
}
utils.WriteStdout(i, data)
}
func runVibrance(cmd *hadfield.Command, args []string) {
image, exif := utils.ReadStdin()
if vibranceExp {
image = vibrance.Exp(image, vibranceBy)
} else {
image = vibrance.Adjust(image, vibranceBy)
}
utils.WriteStdout(image, exif)
}
func run(scale float64, f Cropper) {
img, data := utils.ReadStdin()
b := img.Bounds()
s := int(float64(min(b.Dx(), b.Dy())) * scale)
inner := f(img, s, utils.Centre)
img = blend.Normal(img, flip(inner))
utils.WriteStdout(img, data)
}
func runContrast(cmd *hadfield.Command, args []string) {
i, data := utils.ReadStdin()
if contrastSigmoidal {
i = contrast.Sigmoidal(i, contrastFactor, contrastMidpoint)
} else if contrastLinear {
i = contrast.Linear(i, contrastFactor)
} else {
i = contrast.Adjust(i, contrastFactor)
}
utils.WriteStdout(i, data)
}
func run(paths []string) {
if len(paths) < 2 {
log.Fatal("Require 2 or more images")
}
var data *exif.Exif
images := make([]image.Image, len(paths))
for i, path := range paths {
// Open
file, err := os.Open(path)
if err != nil {
log.Fatal(path, "\n", err)
}
defer file.Close()
// Decode
m, _, err := image.Decode(file)
if err != nil {
log.Fatal(path, "\n", err)
}
if i == 0 {
file.Seek(0, 0)
data = exif.Decode(file)
}
images[i] = m
}
// Assume all photos are the same size as the first (stupid!)
bounds := images[0].Bounds()
// This is the width of a column. It mean that some of the right of an image
// may be sacrificed. But it does mean all columns are exact pixels, and are
// all exactly the same size.
width := bounds.Dx() / len(images)
out := image.NewRGBA(image.Rect(
bounds.Min.X, bounds.Min.Y, bounds.Min.X+(len(images)*width), bounds.Max.Y,
))
for y := bounds.Min.Y; y < bounds.Max.Y; y++ {
for x := bounds.Min.X; x < bounds.Min.X+(len(images)*width); x++ {
col := x / width
out.Set(x, y, images[col].At(x, y))
}
}
utils.WriteStdout(out, data)
}
func runChannel(cmd *hadfield.Command, args []string) {
i, data := utils.ReadStdin()
var adj utils.Adjuster
if utils.FlagVisited("by", cmd.Flag) {
adj = utils.Adder(channelBy)
} else {
adj = utils.Multiplier(channelRatio)
}
if !(channelRed || channelGreen || channelBlue || channelHue ||
channelSaturation || channelLightness || channelBrightness || channelAlpha) {
channelRed = true
channelGreen = true
channelBlue = true
}
if channelRed {
i = channel.Adjust(i, adj, channel.Red)
}
if channelGreen {
i = channel.Adjust(i, adj, channel.Green)
}
if channelBlue {
i = channel.Adjust(i, adj, channel.Blue)
}
if channelHue {
i = channel.Adjust(i, adj, channel.Hue)
}
if channelSaturation {
i = channel.Adjust(i, adj, channel.Saturation)
}
if channelLightness {
i = channel.Adjust(i, adj, channel.Lightness)
}
if channelBrightness {
i = channel.Adjust(i, adj, channel.Brightness)
}
if channelAlpha {
i = channel.Adjust(i, adj, channel.Alpha)
}
utils.WriteStdout(i, data)
}
func main() {
flag.Parse()
img, data := utils.ReadStdin()
s := quantise.LEAST
if *strategy == "MOST" {
s = quantise.MOST
}
img = quantise.Quantise(img, quantise.OctreeQuantiser{
Depth: uint8(*depth),
Size: *size,
Strategy: s,
})
utils.WriteStdout(img, data)
}
func runPixelate(cmd *hadfield.Command, args []string) {
i, data := utils.ReadStdin()
// Default
style := pixelate.FITTED
if pixelateCrop {
style = pixelate.CROPPED
}
if pixelateRows > 0 && pixelateCols > 0 {
pixelateSize = utils.SizeForRowsAndCols(i, pixelateRows, pixelateCols)
} else if pixelateRows > 0 {
pixelateSize = utils.SizeForRows(i, pixelateRows)
} else if pixelateCols > 0 {
pixelateSize = utils.SizeForCols(i, pixelateCols)
}
i = pixelate.Pixelate(i, pixelateSize, style)
utils.WriteStdout(i, data)
}
func runLevels(cmd *hadfield.Command, args []string) {
i, data := utils.ReadStdin()
if !levelsRed && !levelsGreen && !levelsBlue {
levelsRed = true
levelsGreen = true
levelsBlue = true
}
if levelsRed {
i = runLevelsOnChannel(cmd, args, i, channel.Red)
}
if levelsGreen {
i = runLevelsOnChannel(cmd, args, i, channel.Green)
}
if levelsBlue {
i = runLevelsOnChannel(cmd, args, i, channel.Blue)
}
utils.WriteStdout(i, data)
}
func runBlend(cmd *hadfield.Command, args []string) {
if blendModes {
printModes()
}
a, data := utils.ReadStdin()
path := args[0]
file, _ := os.Open(path)
defer file.Close()
b, _, _ := image.Decode(file)
var f (func(a, b image.Image) image.Image)
b = blend.Fade(b, blendOpacity)
if blendFit {
ab := a.Bounds()
bb := b.Bounds()
// Need to work this out better, see
// http://www.codinghorror.com/blog/2007/07/better-image-resizing.html
if bb.Dx() < ab.Dx() || bb.Dy() < ab.Dy() {
// b is going to get BIGGER
b = resize.Resize(uint(ab.Dx()), uint(ab.Dy()), b, resize.Bilinear)
} else {
// b is going to get SMALLER
b = resize.Resize(uint(ab.Dx()), uint(ab.Dy()), b, resize.Bicubic)
}
}
if blendNormal {
f = blend.Normal
} else if blendDissolve {
f = blend.Dissolve
} else if blendDarken {
f = blend.Darken
} else if blendMultiply {
f = blend.Multiply
} else if blendBurn {
f = blend.Burn
} else if blendLinearBurn {
f = blend.LinearBurn
} else if blendDarker {
f = blend.Darker
} else if blendLighten {
f = blend.Lighten
} else if blendScreen {
f = blend.Screen
} else if blendDodge {
f = blend.Dodge
} else if blendLinearDodge {
f = blend.LinearDodge
} else if blendLighter {
f = blend.Lighter
} else if blendOverlay {
f = blend.Overlay
} else if blendSoftLight {
f = blend.SoftLight
} else if blendHardLight {
f = blend.HardLight
} else if blendVividLight {
f = blend.VividLight
} else if blendLinearLight {
f = blend.LinearLight
} else if blendPinLight {
f = blend.PinLight
} else if blendHardMix {
f = blend.HardMix
} else if blendDifference {
f = blend.Difference
} else if blendExclusion {
f = blend.Exclusion
} else if blendAddition {
f = blend.Addition
} else if blendSubtraction {
f = blend.Subtraction
} else if blendHue {
f = blend.Hue
} else if blendSaturation {
f = blend.Saturation
} else if blendColor {
f = blend.Color
} else if blendLuminosity {
f = blend.Luminosity
} else {
f = blend.Normal
}
utils.WriteStdout(f(a, b), data)
}