PixelImage

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

val accessMode: AccessMode[A]

def apply(x: Int, y: Int): A

access image at (x, y)

final def asInstanceOf[T0]: T0

def buffer(implicit tag: ClassTag[A]): PixelImage[A]

buffer the image contents with an Array

def clone(): AnyRef

def col(x: Int): PixelImage[A]

selected column as image, image view only

def curried: (Int) ⇒ (Int) ⇒ A

val domain: PixelImageDomain

final def eq(arg0: AnyRef): Boolean

def equals(other: Any): Boolean

val f: (Int, Int) ⇒ A

def filter[B](imageFilter: ImageFilter[A, B]): PixelImage[B]

apply a generic filter to this image - always non-destructive

def foldLeft[B](init: B)(f: (B, A) ⇒ B): B

fast folding: use for summing without boxing

final def getClass(): Class[_]

def hashCode(): Int

val height: Int

def interpolate(kernel: InterpolationKernel)(implicit ops: ColorSpaceOperations[A]): InterpolatedPixelImage[A]

interpolate the image, cell-based: origin at top left (0.0, 0.0), first pixel (0, 0) at (0.5, 0.5)

def interpolate(implicit ops: ColorSpaceOperations[A]): InterpolatedPixelImage[A]

interpolate the image, use default kernel bilinear

def interpolateNearestNeighbour: NearestNeighbourPixelImage[A]

Nearest neighbouring cell value is chosen for interpolation.

val isBuffered: Boolean

final def isInstanceOf[T0]: Boolean

val length: Int

def map[B](f: (A) ⇒ B)(implicit tag: ClassTag[B]): PixelImage[B]

apply a function to each pixel

def mapLazy[B](f: (A) ⇒ B): PixelImage[B]

apply a function to each pixel

def mapWithIndex[B](f: (A, Int, Int) ⇒ B)(implicit tag: ClassTag[B]): PixelImage[B]

apply a function to each pixel, has access to location of pixel

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def resample(cols: Int, rows: Int)(implicit ops: ColorSpaceOperations[A], tag: ClassTag[A]): PixelImage[A]

resample the image with cols columns and rows, using the bilinear interpolation kernel

def resample(cols: Int, rows: Int, kernel: InterpolationKernel = InterpolationKernel.BilinearKernel)(implicit ops: ColorSpaceOperations[A], tag: ClassTag[A]): PixelImage[A]

resample the image with cols columns and rows, using an interpolation kernel

def resampleNearestNeighbour(cols: Int, rows: Int)(implicit tag: ClassTag[A]): PixelImage[A]

Resamples by taking the nearest neighbour cells for the interpolated value.

def row(y: Int): PixelImage[A]

selected row as image, image view only

final def synchronized[T0](arg0: ⇒ T0): T0

def toArray(implicit tag: ClassTag[A]): Array[A]

get all values as data Array (linearization strategy depends on domain, creates a copy)

def toBuffer(implicit tag: ClassTag[A]): ImageBuffer[A]

create a new ImageBuffer initialized with this image (does not change this image)

def toString(): String

def transposed: PixelImage[A]

transpose image, exchange x and y

def tupled: ((Int, Int)) ⇒ A

def valueAt(x: Int, y: Int): A

direct raw access of image value at (x, y) - unchecked!

def values: Iterator[A]

iterator of all values in image

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

final def wait(): Unit

val width: Int

def withAccessMode(accessMode: AccessMode[A]): PixelImage[A]

change the access mode (boundary behaviour, outside access) of this image

def withDomain(domain: PixelImageDomain): PixelImage[A]

view this image with another domain

def zip[B](other: PixelImage[B]): PixelImage[(A, B)]

zip two images together into a single tupled image

def zipWithIndex: PixelImage[(A, (Int, Int))]

zip pixel values with their location, yields (Color, (x, y))

def finalize(): Unit