java.lang.Object
- net.sourceforge.jiu.color.conversion.LogLuvConversion

```
public class LogLuvConversion
extends Object
```
Convert from LogLuv color representation to RGB color space and from LogL to grayscale.
This implementation is based on the file tif_luv.c which is part of the TIFF library libtiff. The original implementation was written by Greg W. Larson.
Learn more about the color type and its encoding on Greg's page LogLuv Encoding for TIFF Images.

Since:

0.10.0

Author:

Marco Schmidt

Field Summary

Fields
Modifier and Type	Field	Description
`private static double`	`M_LN2`
`private static short[]`	`NCUM`
`private static double`	`U_NEU`
`private static double[]`	`USTART`
`private static int`	`UV_NDIVS`
`private static int`	`UV_NVS`
`private static float`	`UV_SQSIZ`
`private static float`	`UV_VSTART`
`private static double`	`UVSCALE`
`private static double`	`V_NEU`

Constructor Summary

Constructors
Modifier Constructor Description

private LogLuvConversion()

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method	Description
`private static byte`	`convertDoubleToByte(double d)`
`static double`	`convertLogL10toY(int p10)`	Converts an unsigned 10 bit value (the argument must lie in the interval 0 to 1023) to a `double` luminance (brightness) value between `0.0` and `1.0`.
`static void`	`convertLogL16toGray8(byte[] logl, byte[] gray, int num)`	Converts a number of 16 bit LogL samples to 8 bit grayscale samples.
`static double`	`convertLogL16toY(int p16)`	Converts a signed 16 bit value (the argument must lie in the interval -32768 to 32767) to a `double` luminance (brightness) value between `0.0` and `1.0`.
`static void`	`convertLogLuv24InterleavedtoRGB24Planar(byte[] logluv, byte[] red, byte[] green, byte[] blue, int num)`	Converts a number of 24 bit LogLuv pixels to 24 bit RGB pixels.
`static void`	`convertLogLuv32InterleavedtoRGB24Planar(byte[] logluv, byte[] red, byte[] green, byte[] blue, int num)`	Converts a number of 32 bit LogLuv pixels to 24 bit RGB pixels.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - M_LN2
```
private static final double M_LN2
```
    See Also:
    
    Constant Field Values
  - UVSCALE
```
private static final double UVSCALE
```
    See Also:
    
    Constant Field Values
  - UV_SQSIZ
```
private static final float UV_SQSIZ
```
    See Also:
    
    Constant Field Values
  - UV_NDIVS
```
private static final int UV_NDIVS
```
    See Also:
    
    Constant Field Values
  - UV_VSTART
```
private static final float UV_VSTART
```
    See Also:
    
    Constant Field Values
  - UV_NVS
```
private static final int UV_NVS
```
    See Also:
    
    Constant Field Values
  - U_NEU
```
private static final double U_NEU
```
    See Also:
    
    Constant Field Values
  - V_NEU
```
private static final double V_NEU
```
    See Also:
    
    Constant Field Values
  - USTART
```
private static final double[] USTART
```
  - NCUM
```
private static final short[] NCUM
```
- Constructor Detail
  - LogLuvConversion
```
private LogLuvConversion()
```
- Method Detail
  - convertLogL10toY
```
public static double convertLogL10toY(int p10)
```
    Converts an unsigned 10 bit value (the argument must lie in the interval 0 to 1023) to a double luminance (brightness) value between 0.0 and 1.0. This conversion is needed by both LogLuv to XYZ and LogL to grayscale.
    
    Parameters:
    
    p10 - input LogL value
    
    Returns:
    
    double value with luminance, between 0 and 1
  - convertLogL16toY
```
public static double convertLogL16toY(int p16)
```
    Converts a signed 16 bit value (the argument must lie in the interval -32768 to 32767) to a double luminance (brightness) value between 0.0 and 1.0. This conversion is needed by both LogLuv to XYZ and LogL to grayscale.
    
    Parameters:
    
    p16 - input LogL value
    
    Returns:
    
    double value with luminance, between 0 and 1
  - convertDoubleToByte
```
private static byte convertDoubleToByte(double d)
```
  - convertLogLuv24InterleavedtoRGB24Planar
```
public static void convertLogLuv24InterleavedtoRGB24Planar(byte[] logluv,
                                                           byte[] red,
                                                           byte[] green,
                                                           byte[] blue,
                                                           int num)
```
    Converts a number of 24 bit LogLuv pixels to 24 bit RGB pixels. Each LogLuv pixel is stored as three consecutive bytes in the logluv byte array. The first byte and the top two bits of the second are the LogL value, the remaining 14 bits are an index that encodes u and v.
    
    Parameters:
    
    logluv - byte array with LogLuv data, must be at least num * 3 bytes large
    
    red - the byte samples for the red channel will be written to this array
    
    green - the byte samples for the green channel will be written to this array
    
    blue - the byte samples for the blue channel will be written to this array
    
    num - number of pixels to be converted
  - convertLogLuv32InterleavedtoRGB24Planar
```
public static void convertLogLuv32InterleavedtoRGB24Planar(byte[] logluv,
                                                           byte[] red,
                                                           byte[] green,
                                                           byte[] blue,
                                                           int num)
```
    Converts a number of 32 bit LogLuv pixels to 24 bit RGB pixels. Each LogLuv pixel is stored as four consecutive bytes in the logluv byte array. The first two bytes represent the LogL value (most significant bytefirst), followed by the u value and then the v value.
    
    Parameters:
    
    logluv - byte array with LogLuv data, must be at least num * 4 bytes large
    
    red - the byte samples for the red channel will be written to this array
    
    green - the byte samples for the green channel will be written to this array
    
    blue - the byte samples for the blue channel will be written to this array
    
    num - number of pixels to be converted
  - convertLogL16toGray8
```
public static void convertLogL16toGray8(byte[] logl,
                                        byte[] gray,
                                        int num)
```
    Converts a number of 16 bit LogL samples to 8 bit grayscale samples.
    
    Parameters:
    
    logl - byte array with LogL samples, each 16 bit sample is stored as two consecutive bytes in order most-significant-byte least-significant-byte (network byte order); the array must be at least num * 2 entries large
    
    gray - the byte array to which the converted samples will be written
    
    num - the number of samples to be converted

Class LogLuvConversion

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

M_LN2

UVSCALE

UV_SQSIZ

UV_NDIVS

UV_VSTART

UV_NVS

U_NEU

V_NEU

USTART

NCUM

Constructor Detail

LogLuvConversion

Method Detail

convertLogL10toY

convertLogL16toY

convertDoubleToByte

convertLogLuv24InterleavedtoRGB24Planar

convertLogLuv32InterleavedtoRGB24Planar

convertLogL16toGray8