Calibration.java

package ij.measure;
import ij.*;

public class Calibration {

    public static final int STRAIGHT_LINE=0,POLY2=1,POLY3=2,POLY4=3,
        EXPONENTIAL=4,POWER=5,LOG=6,RODBARD=7,GAMMA_VARIATE=8, LOG2=9;
    public static final int NONE=20, UNCALIBRATED_OD=21;

    public double pixelWidth = 1.0;
    
    public double pixelHeight = 1.0;
    
    public double pixelDepth = 1.0;
    
    public double frameInterval;

    public double xOrigin;

    public double yOrigin;

    public double zOrigin;

    public String info;

    private double[] coefficients;
        
    /* Distance unit (e.g. 'cm', 'inch') */
    private String unit = "pixel";
    
    /* Distance units (e.g. 'microns', 'inches') */
    private String units;

    /* Pixel value unit (e.g. 'gray level', 'OD') */
    private String valueUnit = "Gray Value";

    /* Calibration function ID */
    private int function = NONE;

    /* Calibration table */
    private float[] cTable;
    
    private boolean invertedLut;
    private int bitDepth = 8;
    private boolean zeroClip;

    public Calibration(ImagePlus imp) {
        if (imp!=null) {
            bitDepth = imp.getBitDepth();
            invertedLut = imp.isInvertedLut();
        }
    }
    
    public Calibration() {
    }
    
    public boolean scaled() {
        return pixelWidth!=1.0 || pixelHeight!=1.0 || pixelDepth!=1.0;
    }
    
    public void setUnit(String unit) {
        if (unit==null || unit.equals(""))
            this.unit = "pixel";
        else
            this.unit = unit;
        units = null;
    }
    
    public String getUnit() {
        return unit;
    }
    
    public String getUnits() {
        if (units==null) {
            if (unit.equals("pixel"))
                units = "pixels";
            else if (unit.equals("micron"))
                units = "microns";
            else if (unit.equals("inch"))
                units = "inches";
            else
                units = unit;
        }
        return units;
    }
    
    public double getX(int x) {
        return (x-xOrigin)*pixelWidth;
    }
    
    public double getY(int y) {
        return (y-yOrigin)*pixelHeight;
    }
    
    public double getZ(int z) {
        return (z-zOrigin)*pixelDepth;
    }
    
    public void setFunction(int function, double[] coefficients, String unit) {
        setFunction(function, coefficients, unit, false);
    }
    
    public void setFunction(int function, double[] coefficients, String unit, boolean zeroClip) {
        if (function==NONE)
            {disableDensityCalibration(); return;}
        if (coefficients==null && function>=STRAIGHT_LINE && function<=LOG2)
            return;
        this.function = function;
        this.coefficients = coefficients;
        this.zeroClip = zeroClip;
        if (unit!=null)
            valueUnit = unit;
        cTable = null;
    }

    public void setImage(ImagePlus imp) {
        if (imp==null)
            return;
        int type = imp.getType();
        int newBitDepth = imp.getBitDepth();
        if (newBitDepth!=bitDepth || type==ImagePlus.GRAY32 || type==ImagePlus.COLOR_RGB)
            disableDensityCalibration();
        bitDepth = newBitDepth;
    }
    
    public void disableDensityCalibration() {
        function = NONE;
        coefficients = null;
        cTable = null;
        valueUnit = "Gray Value";
    }
    
    public String getValueUnit() {
        return valueUnit;
    }
    
    public void setValueUnit(String unit) {
        if (unit!=null)
            valueUnit = unit;
    }

    public double[] getCoefficients() {
        return coefficients;
    }

    public boolean calibrated() {
        return function!=NONE;
    }
    
    public int getFunction() {
        return function;
    }
    
    public float[] getCTable() {
        if (cTable==null)
            makeCTable();
        return cTable;
    }
    
    void makeCTable() {
        if (bitDepth==16)
            {make16BitCTable(); return;}
        if (bitDepth!=8)
            return;
        if (function==UNCALIBRATED_OD) {
            cTable = new float[256];
            for (int i=0; i<256; i++)
                cTable[i] = (float)od(i);
        } else if (function>=STRAIGHT_LINE && function<=LOG2 && coefficients!=null) {
            cTable = new float[256];
            double value;
            for (int i=0; i<256; i++) {
                value = CurveFitter.f(function, coefficients, i);
                if (zeroClip && value<0.0)
                    cTable[i] = 0f;
                else
                    cTable[i] = (float)value;
            }
        } else
            cTable = null;
    }

    void make16BitCTable() {
        if (function>=STRAIGHT_LINE && function<=LOG2 && coefficients!=null) {
            cTable = new float[65536];
            for (int i=0; i<65536; i++)
                cTable[i] = (float)CurveFitter.f(function, coefficients, i);
        } else
            cTable = null;
    }

    double od(double v) {
        if (invertedLut) {
            if (v==255.0) v = 254.5;
            return 0.434294481*Math.log(255.0/(255.0-v));
        } else {
            if (v==0.0) v = 0.5;
            return 0.434294481*Math.log(255.0/v);
        }
    }
    
    public double getCValue(int value) {
        if (function==NONE)
            return value;
        if (function>=STRAIGHT_LINE && function<=LOG2 && coefficients!=null) {
            double v = CurveFitter.f(function, coefficients, value);
            if (zeroClip && v<0.0)
                return 0.0;
            else
                return v;
        } if (cTable==null)
            makeCTable();
        if (cTable!=null && value>=0 && value<cTable.length)
            return cTable[value];
        else
            return value;
    }
        
    public double getCValue(double value) {
        if (function==NONE)
            return value;
        else {
            if (function>=STRAIGHT_LINE && function<=LOG2 && coefficients!=null) {
                double v = CurveFitter.f(function, coefficients, value);
                if (zeroClip && v<0.0)
                    return 0.0;
                else
                    return v;
            } else
                return getCValue((int)value);
        }
    }

    public double getRawValue(double value) {
        if (function==NONE)
            return value;
        if (cTable==null)
            makeCTable();
        float fvalue = (float)value;
        float smallestDiff = Float.MAX_VALUE;
        float diff;
        int index = 0;
        for (int i=0; i<cTable.length; i++) {
            diff = fvalue - cTable[i];
            if (diff<0f) diff = -diff;
            if (diff<smallestDiff) {
                smallestDiff = diff;
                index = i;
            }
        }
        return index;
    }
        
    public Calibration copy() {
        Calibration copy = new Calibration();
        copy.pixelWidth = pixelWidth;
        copy.pixelHeight = pixelHeight;
        copy.pixelDepth = pixelDepth;
        copy.frameInterval = frameInterval;
        copy.xOrigin = xOrigin;
        copy.yOrigin = yOrigin;
        copy.zOrigin = zOrigin;
        copy.info = info;
        copy.unit = unit;
        copy.units = units;
        copy.valueUnit = valueUnit;
        copy.function = function;
        copy.coefficients = coefficients;
        copy.cTable = cTable;
        copy.invertedLut = invertedLut;
        copy.bitDepth = bitDepth;
        copy.zeroClip = zeroClip;
        return copy;
    }
    
    public boolean equals(Calibration cal) {
        if (cal==null)
            return false;
        boolean equal = true;
        if (cal.pixelWidth!=pixelWidth || cal.pixelHeight!=pixelHeight || cal.pixelDepth!=pixelDepth)
            equal = false;
        if (!cal.unit.equals(unit))
            equal = false;
        if (!cal.valueUnit.equals(valueUnit) || cal.function!=function)
            equal = false;
        return equal;
    }
    
    public boolean isSigned16Bit() {
        return bitDepth==16 && cTable!=null && cTable[0]==-32768;
    }
 
    public String toString() {
        return
            "w=" + pixelWidth
            + ", h=" + pixelHeight
            + ", d=" + pixelDepth
            + ", unit=" + unit
            + ", f=" + function
            + ", nc=" + (coefficients!=null?""+coefficients.length:"null")
            + ", table=" + (cTable!=null?""+cTable.length:"null")
            + ", vunit=" + valueUnit;
   }
}