ires 0.1.0

data/ext/util/uri/uri.go

@@ -0,0 +1,96 @@
+package util
+
+import (
+	"os"
+	"path/filepath"
+	"strconv"
+	"strings"
+	"io/ioutil"
+)
+
+// ローカルの画像かどうか
+func IsLocalFile(path string) bool {
+	if strings.Index(path, "http") == -1 {
+		return true
+	} else {
+		return false
+	}
+}
+
+// 画像名を取得
+func getImageName(uri string) (string, string) {
+	splitPath 	:= strings.Split(uri, "/")
+	fileName 	:= splitPath[len(splitPath)-1]		// ex. sample.jpg
+	ext 		:= filepath.Ext(fileName)			// ex. .jpg
+	return strings.Replace(fileName, ext, "", 1), ext
+}
+
+// 画像のフルパスを生成
+func NewImagePath(uri, dir string, mode int, size ...int) string {
+	name := NewImageName(uri, size...)
+	return FilePath(name, dir, mode, size...)
+}
+
+// ファイル名を生成
+func NewImageName(uri string, size ...int) string {
+	imageName, ext := getImageName(uri)
+	if len(size) == 2 {
+		imageName += "_" + PrefixSize(size...)
+	}
+	imageName += ext
+	return imageName
+}
+
+// 画像を保存するパスの設定
+func FilePath(name string, d string, mode int, size ...int) string {
+	paths := []rune(d)
+	pathsLastIndex := len(paths) - 1
+	lastChar := string(paths[pathsLastIndex])
+	if lastChar == "/" {
+		d = string(paths[:pathsLastIndex])
+	}
+
+	// 画像格納先
+	var oDir string
+	switch mode {
+	case 0: 	oDir = "ires/resize"
+	case 1: 	oDir = "ires/crop"
+	case 2: 	oDir = "ires/resize_to_crop"
+	default: 	oDir = "ires/original"
+	}
+
+	var prefix string
+	if len(size) == 2 {
+		prefix = PrefixSize(size...)
+	} else {
+		prefix = "original"
+	}
+	oDir += "/" + prefix
+
+	// Create directory
+	oPath := filepath.Join(d, oDir)
+	if _, err := os.Stat(oPath); err != nil {
+		if err := os.MkdirAll(oPath, 0777); err != nil {
+			panic(err)
+		}
+	}
+
+	pullPath := filepath.Join(oPath, name)
+	return pullPath
+}
+
+// サイズからプレフィックスを作成 ex. 640x480
+func PrefixSize(size ...int) string {
+	prefix := strconv.Itoa(size[0]) + "x" + strconv.Itoa(size[1])
+	return prefix
+}
+
+// リサイズ済みのファイルがあれば、処理せず返す
+func IsEmptyImage(path string) bool {
+	_, err := ioutil.ReadFile(path)
+	if err != nil {
+		return true
+	} else {
+		return false
+	}
+}

data/ext/vendor/github.com/nfnt/resize/LICENSE

@@ -0,0 +1,13 @@
+Copyright (c) 2012, Jan Schlicht <jan.schlicht@gmail.com>
+
+Permission to use, copy, modify, and/or distribute this software for any purpose
+with or without fee is hereby granted, provided that the above copyright notice
+and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
+THIS SOFTWARE.

data/ext/vendor/github.com/nfnt/resize/README.md

@@ -0,0 +1,149 @@
+Resize
+======
+
+Image resizing for the [Go programming language](http://golang.org) with common interpolation methods.
+
+[![Build Status](https://travis-ci.org/nfnt/resize.svg)](https://travis-ci.org/nfnt/resize)
+
+Installation
+------------
+
+```bash
+$ go get github.com/nfnt/resize
+```
+
+It's that easy!
+
+Usage
+-----
+
+This package needs at least Go 1.1. Import package with
+
+```go
+import "github.com/nfnt/resize"
+```
+
+The resize package provides 2 functions:
+
+* `resize.Resize` creates a scaled image with new dimensions (`width`, `height`) using the interpolation function `interp`.
+  If either `width` or `height` is set to 0, it will be set to an aspect ratio preserving value.
+* `resize.Thumbnail` downscales an image preserving its aspect ratio to the maximum dimensions (`maxWidth`, `maxHeight`).
+  It will return the original image if original sizes are smaller than the provided dimensions.
+
+```go
+resize.Resize(width, height uint, img image.Image, interp resize.InterpolationFunction) image.Image
+resize.Thumbnail(maxWidth, maxHeight uint, img image.Image, interp resize.InterpolationFunction) image.Image
+```
+
+The provided interpolation functions are (from fast to slow execution time)
+
+- `NearestNeighbor`: [Nearest-neighbor interpolation](http://en.wikipedia.org/wiki/Nearest-neighbor_interpolation)
+- `Bilinear`: [Bilinear interpolation](http://en.wikipedia.org/wiki/Bilinear_interpolation)
+- `Bicubic`: [Bicubic interpolation](http://en.wikipedia.org/wiki/Bicubic_interpolation)
+- `MitchellNetravali`: [Mitchell-Netravali interpolation](http://dl.acm.org/citation.cfm?id=378514)
+- `Lanczos2`: [Lanczos resampling](http://en.wikipedia.org/wiki/Lanczos_resampling) with a=2
+- `Lanczos3`: [Lanczos resampling](http://en.wikipedia.org/wiki/Lanczos_resampling) with a=3
+
+Which of these methods gives the best results depends on your use case.
+
+Sample usage:
+
+```go
+package main
+
+import (
+	"github.com/nfnt/resize"
+	"image/jpeg"
+	"log"
+	"os"
+)
+
+func main() {
+	// open "test.jpg"
+	file, err := os.Open("test.jpg")
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	// decode jpeg into image.Image
+	img, err := jpeg.Decode(file)
+	if err != nil {
+		log.Fatal(err)
+	}
+	file.Close()
+
+	// resize to width 1000 using Lanczos resampling
+	// and preserve aspect ratio
+	m := resize.Resize(1000, 0, img, resize.Lanczos3)
+
+	out, err := os.Create("test_resized.jpg")
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer out.Close()
+
+	// write new image to file
+	jpeg.Encode(out, m, nil)
+}
+```
+
+Caveats
+-------
+
+* Optimized access routines are used for `image.RGBA`, `image.NRGBA`, `image.RGBA64`, `image.NRGBA64`, `image.YCbCr`, `image.Gray`, and `image.Gray16` types. All other image types are accessed in a generic way that will result in slow processing speed.
+* JPEG images are stored in `image.YCbCr`. This image format stores data in a way that will decrease processing speed. A resize may be up to 2 times slower than with `image.RGBA`. 
+
+
+Downsizing Samples
+-------
+
+Downsizing is not as simple as it might look like. Images have to be filtered before they are scaled down, otherwise aliasing might occur.
+Filtering is highly subjective: Applying too much will blur the whole image, too little will make aliasing become apparent.
+Resize tries to provide sane defaults that should suffice in most cases.
+
+### Artificial sample
+
+Original image
+![Rings](http://nfnt.github.com/img/rings_lg_orig.png)
+
+<table>
+<tr>
+<th><img src="http://nfnt.github.com/img/rings_300_NearestNeighbor.png" /><br>Nearest-Neighbor</th>
+<th><img src="http://nfnt.github.com/img/rings_300_Bilinear.png" /><br>Bilinear</th>
+</tr>
+<tr>
+<th><img src="http://nfnt.github.com/img/rings_300_Bicubic.png" /><br>Bicubic</th>
+<th><img src="http://nfnt.github.com/img/rings_300_MitchellNetravali.png" /><br>Mitchell-Netravali</th>
+</tr>
+<tr>
+<th><img src="http://nfnt.github.com/img/rings_300_Lanczos2.png" /><br>Lanczos2</th>
+<th><img src="http://nfnt.github.com/img/rings_300_Lanczos3.png" /><br>Lanczos3</th>
+</tr>
+</table>
+
+### Real-Life sample
+
+Original image  
+![Original](http://nfnt.github.com/img/IMG_3694_720.jpg)
+
+<table>
+<tr>
+<th><img src="http://nfnt.github.com/img/IMG_3694_300_NearestNeighbor.png" /><br>Nearest-Neighbor</th>
+<th><img src="http://nfnt.github.com/img/IMG_3694_300_Bilinear.png" /><br>Bilinear</th>
+</tr>
+<tr>
+<th><img src="http://nfnt.github.com/img/IMG_3694_300_Bicubic.png" /><br>Bicubic</th>
+<th><img src="http://nfnt.github.com/img/IMG_3694_300_MitchellNetravali.png" /><br>Mitchell-Netravali</th>
+</tr>
+<tr>
+<th><img src="http://nfnt.github.com/img/IMG_3694_300_Lanczos2.png" /><br>Lanczos2</th>
+<th><img src="http://nfnt.github.com/img/IMG_3694_300_Lanczos3.png" /><br>Lanczos3</th>
+</tr>
+</table>
+
+
+License
+-------
+
+Copyright (c) 2012 Jan Schlicht <janschlicht@gmail.com>
+Resize is released under a MIT style license.

data/ext/vendor/github.com/nfnt/resize/converter.go

@@ -0,0 +1,438 @@
+/*
+Copyright (c) 2012, Jan Schlicht <jan.schlicht@gmail.com>
+
+Permission to use, copy, modify, and/or distribute this software for any purpose
+with or without fee is hereby granted, provided that the above copyright notice
+and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
+THIS SOFTWARE.
+*/
+
+package resize
+
+import "image"
+
+// Keep value in [0,255] range.
+func clampUint8(in int32) uint8 {
+	// casting a negative int to an uint will result in an overflown
+	// large uint. this behavior will be exploited here and in other functions
+	// to achieve a higher performance.
+	if uint32(in) < 256 {
+		return uint8(in)
+	}
+	if in > 255 {
+		return 255
+	}
+	return 0
+}
+
+// Keep value in [0,65535] range.
+func clampUint16(in int64) uint16 {
+	if uint64(in) < 65536 {
+		return uint16(in)
+	}
+	if in > 65535 {
+		return 65535
+	}
+	return 0
+}
+
+func resizeGeneric(in image.Image, out *image.RGBA64, scale float64, coeffs []int32, offset []int, filterLength int) {
+	newBounds := out.Bounds()
+	maxX := in.Bounds().Dx() - 1
+
+	for x := newBounds.Min.X; x < newBounds.Max.X; x++ {
+		for y := newBounds.Min.Y; y < newBounds.Max.Y; y++ {
+			var rgba [4]int64
+			var sum int64
+			start := offset[y]
+			ci := y * filterLength
+			for i := 0; i < filterLength; i++ {
+				coeff := coeffs[ci+i]
+				if coeff != 0 {
+					xi := start + i
+					switch {
+					case xi < 0:
+						xi = 0
+					case xi >= maxX:
+						xi = maxX
+					}
+
+					r, g, b, a := in.At(xi+in.Bounds().Min.X, x+in.Bounds().Min.Y).RGBA()
+
+					rgba[0] += int64(coeff) * int64(r)
+					rgba[1] += int64(coeff) * int64(g)
+					rgba[2] += int64(coeff) * int64(b)
+					rgba[3] += int64(coeff) * int64(a)
+					sum += int64(coeff)
+				}
+			}
+
+			offset := (y-newBounds.Min.Y)*out.Stride + (x-newBounds.Min.X)*8
+
+			value := clampUint16(rgba[0] / sum)
+			out.Pix[offset+0] = uint8(value >> 8)
+			out.Pix[offset+1] = uint8(value)
+			value = clampUint16(rgba[1] / sum)
+			out.Pix[offset+2] = uint8(value >> 8)
+			out.Pix[offset+3] = uint8(value)
+			value = clampUint16(rgba[2] / sum)
+			out.Pix[offset+4] = uint8(value >> 8)
+			out.Pix[offset+5] = uint8(value)
+			value = clampUint16(rgba[3] / sum)
+			out.Pix[offset+6] = uint8(value >> 8)
+			out.Pix[offset+7] = uint8(value)
+		}
+	}
+}
+
+func resizeRGBA(in *image.RGBA, out *image.RGBA, scale float64, coeffs []int16, offset []int, filterLength int) {
+	newBounds := out.Bounds()
+	maxX := in.Bounds().Dx() - 1
+
+	for x := newBounds.Min.X; x < newBounds.Max.X; x++ {
+		row := in.Pix[x*in.Stride:]
+		for y := newBounds.Min.Y; y < newBounds.Max.Y; y++ {
+			var rgba [4]int32
+			var sum int32
+			start := offset[y]
+			ci := y * filterLength
+			for i := 0; i < filterLength; i++ {
+				coeff := coeffs[ci+i]
+				if coeff != 0 {
+					xi := start + i
+					switch {
+					case uint(xi) < uint(maxX):
+						xi *= 4
+					case xi >= maxX:
+						xi = 4 * maxX
+					default:
+						xi = 0
+					}
+
+					rgba[0] += int32(coeff) * int32(row[xi+0])
+					rgba[1] += int32(coeff) * int32(row[xi+1])
+					rgba[2] += int32(coeff) * int32(row[xi+2])
+					rgba[3] += int32(coeff) * int32(row[xi+3])
+					sum += int32(coeff)
+				}
+			}
+
+			xo := (y-newBounds.Min.Y)*out.Stride + (x-newBounds.Min.X)*4
+
+			out.Pix[xo+0] = clampUint8(rgba[0] / sum)
+			out.Pix[xo+1] = clampUint8(rgba[1] / sum)
+			out.Pix[xo+2] = clampUint8(rgba[2] / sum)
+			out.Pix[xo+3] = clampUint8(rgba[3] / sum)
+		}
+	}
+}
+
+func resizeNRGBA(in *image.NRGBA, out *image.RGBA, scale float64, coeffs []int16, offset []int, filterLength int) {
+	newBounds := out.Bounds()
+	maxX := in.Bounds().Dx() - 1
+
+	for x := newBounds.Min.X; x < newBounds.Max.X; x++ {
+		row := in.Pix[x*in.Stride:]
+		for y := newBounds.Min.Y; y < newBounds.Max.Y; y++ {
+			var rgba [4]int32
+			var sum int32
+			start := offset[y]
+			ci := y * filterLength
+			for i := 0; i < filterLength; i++ {
+				coeff := coeffs[ci+i]
+				if coeff != 0 {
+					xi := start + i
+					switch {
+					case uint(xi) < uint(maxX):
+						xi *= 4
+					case xi >= maxX:
+						xi = 4 * maxX
+					default:
+						xi = 0
+					}
+
+					// Forward alpha-premultiplication
+					a := int32(row[xi+3])
+					r := int32(row[xi+0]) * a
+					r /= 0xff
+					g := int32(row[xi+1]) * a
+					g /= 0xff
+					b := int32(row[xi+2]) * a
+					b /= 0xff
+
+					rgba[0] += int32(coeff) * r
+					rgba[1] += int32(coeff) * g
+					rgba[2] += int32(coeff) * b
+					rgba[3] += int32(coeff) * a
+					sum += int32(coeff)
+				}
+			}
+
+			xo := (y-newBounds.Min.Y)*out.Stride + (x-newBounds.Min.X)*4
+
+			out.Pix[xo+0] = clampUint8(rgba[0] / sum)
+			out.Pix[xo+1] = clampUint8(rgba[1] / sum)
+			out.Pix[xo+2] = clampUint8(rgba[2] / sum)
+			out.Pix[xo+3] = clampUint8(rgba[3] / sum)
+		}
+	}
+}
+
+func resizeRGBA64(in *image.RGBA64, out *image.RGBA64, scale float64, coeffs []int32, offset []int, filterLength int) {
+	newBounds := out.Bounds()
+	maxX := in.Bounds().Dx() - 1
+
+	for x := newBounds.Min.X; x < newBounds.Max.X; x++ {
+		row := in.Pix[x*in.Stride:]
+		for y := newBounds.Min.Y; y < newBounds.Max.Y; y++ {
+			var rgba [4]int64
+			var sum int64
+			start := offset[y]
+			ci := y * filterLength
+			for i := 0; i < filterLength; i++ {
+				coeff := coeffs[ci+i]
+				if coeff != 0 {
+					xi := start + i
+					switch {
+					case uint(xi) < uint(maxX):
+						xi *= 8
+					case xi >= maxX:
+						xi = 8 * maxX
+					default:
+						xi = 0
+					}
+
+					rgba[0] += int64(coeff) * (int64(row[xi+0])<<8 | int64(row[xi+1]))
+					rgba[1] += int64(coeff) * (int64(row[xi+2])<<8 | int64(row[xi+3]))
+					rgba[2] += int64(coeff) * (int64(row[xi+4])<<8 | int64(row[xi+5]))
+					rgba[3] += int64(coeff) * (int64(row[xi+6])<<8 | int64(row[xi+7]))
+					sum += int64(coeff)
+				}
+			}
+
+			xo := (y-newBounds.Min.Y)*out.Stride + (x-newBounds.Min.X)*8
+
+			value := clampUint16(rgba[0] / sum)
+			out.Pix[xo+0] = uint8(value >> 8)
+			out.Pix[xo+1] = uint8(value)
+			value = clampUint16(rgba[1] / sum)
+			out.Pix[xo+2] = uint8(value >> 8)
+			out.Pix[xo+3] = uint8(value)
+			value = clampUint16(rgba[2] / sum)
+			out.Pix[xo+4] = uint8(value >> 8)
+			out.Pix[xo+5] = uint8(value)
+			value = clampUint16(rgba[3] / sum)
+			out.Pix[xo+6] = uint8(value >> 8)
+			out.Pix[xo+7] = uint8(value)
+		}
+	}
+}
+
+func resizeNRGBA64(in *image.NRGBA64, out *image.RGBA64, scale float64, coeffs []int32, offset []int, filterLength int) {
+	newBounds := out.Bounds()
+	maxX := in.Bounds().Dx() - 1
+
+	for x := newBounds.Min.X; x < newBounds.Max.X; x++ {
+		row := in.Pix[x*in.Stride:]
+		for y := newBounds.Min.Y; y < newBounds.Max.Y; y++ {
+			var rgba [4]int64
+			var sum int64
+			start := offset[y]
+			ci := y * filterLength
+			for i := 0; i < filterLength; i++ {
+				coeff := coeffs[ci+i]
+				if coeff != 0 {
+					xi := start + i
+					switch {
+					case uint(xi) < uint(maxX):
+						xi *= 8
+					case xi >= maxX:
+						xi = 8 * maxX
+					default:
+						xi = 0
+					}
+
+					// Forward alpha-premultiplication
+					a := int64(uint16(row[xi+6])<<8 | uint16(row[xi+7]))
+					r := int64(uint16(row[xi+0])<<8|uint16(row[xi+1])) * a
+					r /= 0xffff
+					g := int64(uint16(row[xi+2])<<8|uint16(row[xi+3])) * a
+					g /= 0xffff
+					b := int64(uint16(row[xi+4])<<8|uint16(row[xi+5])) * a
+					b /= 0xffff
+
+					rgba[0] += int64(coeff) * r
+					rgba[1] += int64(coeff) * g
+					rgba[2] += int64(coeff) * b
+					rgba[3] += int64(coeff) * a
+					sum += int64(coeff)
+				}
+			}
+
+			xo := (y-newBounds.Min.Y)*out.Stride + (x-newBounds.Min.X)*8
+
+			value := clampUint16(rgba[0] / sum)
+			out.Pix[xo+0] = uint8(value >> 8)
+			out.Pix[xo+1] = uint8(value)
+			value = clampUint16(rgba[1] / sum)
+			out.Pix[xo+2] = uint8(value >> 8)
+			out.Pix[xo+3] = uint8(value)
+			value = clampUint16(rgba[2] / sum)
+			out.Pix[xo+4] = uint8(value >> 8)
+			out.Pix[xo+5] = uint8(value)
+			value = clampUint16(rgba[3] / sum)
+			out.Pix[xo+6] = uint8(value >> 8)
+			out.Pix[xo+7] = uint8(value)
+		}
+	}
+}
+
+func resizeGray(in *image.Gray, out *image.Gray, scale float64, coeffs []int16, offset []int, filterLength int) {
+	newBounds := out.Bounds()
+	maxX := in.Bounds().Dx() - 1
+
+	for x := newBounds.Min.X; x < newBounds.Max.X; x++ {
+		row := in.Pix[(x-newBounds.Min.X)*in.Stride:]
+		for y := newBounds.Min.Y; y < newBounds.Max.Y; y++ {
+			var gray int32
+			var sum int32
+			start := offset[y]
+			ci := y * filterLength
+			for i := 0; i < filterLength; i++ {
+				coeff := coeffs[ci+i]
+				if coeff != 0 {
+					xi := start + i
+					switch {
+					case xi < 0:
+						xi = 0
+					case xi >= maxX:
+						xi = maxX
+					}
+					gray += int32(coeff) * int32(row[xi])
+					sum += int32(coeff)
+				}
+			}
+
+			offset := (y-newBounds.Min.Y)*out.Stride + (x - newBounds.Min.X)
+			out.Pix[offset] = clampUint8(gray / sum)
+		}
+	}
+}
+
+func resizeGray16(in *image.Gray16, out *image.Gray16, scale float64, coeffs []int32, offset []int, filterLength int) {
+	newBounds := out.Bounds()
+	maxX := in.Bounds().Dx() - 1
+
+	for x := newBounds.Min.X; x < newBounds.Max.X; x++ {
+		row := in.Pix[x*in.Stride:]
+		for y := newBounds.Min.Y; y < newBounds.Max.Y; y++ {
+			var gray int64
+			var sum int64
+			start := offset[y]
+			ci := y * filterLength
+			for i := 0; i < filterLength; i++ {
+				coeff := coeffs[ci+i]
+				if coeff != 0 {
+					xi := start + i
+					switch {
+					case uint(xi) < uint(maxX):
+						xi *= 2
+					case xi >= maxX:
+						xi = 2 * maxX
+					default:
+						xi = 0
+					}
+					gray += int64(coeff) * int64(uint16(row[xi+0])<<8|uint16(row[xi+1]))
+					sum += int64(coeff)
+				}
+			}
+
+			offset := (y-newBounds.Min.Y)*out.Stride + (x-newBounds.Min.X)*2
+			value := clampUint16(gray / sum)
+			out.Pix[offset+0] = uint8(value >> 8)
+			out.Pix[offset+1] = uint8(value)
+		}
+	}
+}
+
+func resizeYCbCr(in *ycc, out *ycc, scale float64, coeffs []int16, offset []int, filterLength int) {
+	newBounds := out.Bounds()
+	maxX := in.Bounds().Dx() - 1
+
+	for x := newBounds.Min.X; x < newBounds.Max.X; x++ {
+		row := in.Pix[x*in.Stride:]
+		for y := newBounds.Min.Y; y < newBounds.Max.Y; y++ {
+			var p [3]int32
+			var sum int32
+			start := offset[y]
+			ci := y * filterLength
+			for i := 0; i < filterLength; i++ {
+				coeff := coeffs[ci+i]
+				if coeff != 0 {
+					xi := start + i
+					switch {
+					case uint(xi) < uint(maxX):
+						xi *= 3
+					case xi >= maxX:
+						xi = 3 * maxX
+					default:
+						xi = 0
+					}
+					p[0] += int32(coeff) * int32(row[xi+0])
+					p[1] += int32(coeff) * int32(row[xi+1])
+					p[2] += int32(coeff) * int32(row[xi+2])
+					sum += int32(coeff)
+				}
+			}
+
+			xo := (y-newBounds.Min.Y)*out.Stride + (x-newBounds.Min.X)*3
+			out.Pix[xo+0] = clampUint8(p[0] / sum)
+			out.Pix[xo+1] = clampUint8(p[1] / sum)
+			out.Pix[xo+2] = clampUint8(p[2] / sum)
+		}
+	}
+}
+
+func nearestYCbCr(in *ycc, out *ycc, scale float64, coeffs []bool, offset []int, filterLength int) {
+	newBounds := out.Bounds()
+	maxX := in.Bounds().Dx() - 1
+
+	for x := newBounds.Min.X; x < newBounds.Max.X; x++ {
+		row := in.Pix[x*in.Stride:]
+		for y := newBounds.Min.Y; y < newBounds.Max.Y; y++ {
+			var p [3]float32
+			var sum float32
+			start := offset[y]
+			ci := y * filterLength
+			for i := 0; i < filterLength; i++ {
+				if coeffs[ci+i] {
+					xi := start + i
+					switch {
+					case uint(xi) < uint(maxX):
+						xi *= 3
+					case xi >= maxX:
+						xi = 3 * maxX
+					default:
+						xi = 0
+					}
+					p[0] += float32(row[xi+0])
+					p[1] += float32(row[xi+1])
+					p[2] += float32(row[xi+2])
+					sum++
+				}
+			}
+
+			xo := (y-newBounds.Min.Y)*out.Stride + (x-newBounds.Min.X)*3
+			out.Pix[xo+0] = floatToUint8(p[0] / sum)
+			out.Pix[xo+1] = floatToUint8(p[1] / sum)
+			out.Pix[xo+2] = floatToUint8(p[2] / sum)
+		}
+	}
+}