private ImageFileDirectory SetMembers()
{
//Raw Data:
ImageFileDirectory raw = mIfds[0];
IFDExif exif = raw.GetEntry <IFDExif>();
mISO = exif.GetEntry <ExifISOSpeedRatings>().Value;
mExposureTime = exif.GetEntry <ExifExposureTime>().Value;
mRecordingDate = exif.GetEntry <ExifDateTimeDigitized>().Value;
mBitDepth = raw.GetEntry <IFDBitsPerSample>().Value[0];
ExifMakerNote makernote = exif.GetEntry <ExifMakerNote>();
//needed to decompress image data:
mHhuffmanTable = makernote.Value.GetEntry <MNHuffmanTable>();
ExifCFAPattern.BayerColor[] bayer = exif.GetEntry <ExifCFAPattern>().Value;
mBayerPattern = new BayerColor[bayer.Length];
for (int i = 0; i < bayer.Length; i++)
{
mBayerPattern[i] = (BayerColor)(int)bayer[i];
}
MNWhiteLevel whiteLevel = makernote.Value.GetEntry <MNWhiteLevel>();
MNWhitePoint whitePoint = makernote.Value.GetEntry <MNWhitePoint>();
MNBlackPoint blackPoint = makernote.Value.GetEntry <MNBlackPoint>();
MNDataScaling scaling = makernote.Value.GetEntry <MNDataScaling>();
float whiteLevelAll = (float)Math.Pow(2, mBitDepth);
if (whiteLevel != null)
{
whiteLevelAll = whiteLevel.Value;
}
mBlackLevel = new float[3];
if (blackPoint != null)
{
//only one value for all colors
if (blackPoint.Value.Length == 1)
{
mBlackLevel[0] = (float)blackPoint.Value[0];
mBlackLevel[1] = (float)blackPoint.Value[0];
mBlackLevel[2] = (float)blackPoint.Value[0];
}
//values per color channel
if (blackPoint.Value.Length == 3)
{
mBlackLevel[0] = (float)blackPoint.Value[0];
mBlackLevel[1] = (float)blackPoint.Value[1];
mBlackLevel[2] = (float)blackPoint.Value[2];
}
//values per color bayer pattern
if (blackPoint.Value.Length == 4)
{
//red
int indexR = -1;
for (int i = 0; i < mBayerPattern.Length; i++)
{
if (mBayerPattern[i] == BayerColor.Red)
{
indexR = i;
break;
}
}
mBlackLevel[0] = (float)blackPoint.Value[indexR];
//blue
int indexB = -1;
for (int i = 0; i < mBayerPattern.Length; i++)
{
if (mBayerPattern[i] == BayerColor.Blue)
{
indexB = i;
break;
}
}
mBlackLevel[2] = (float)blackPoint.Value[indexB];
//green, the two remaining indices
int indexG1 = -1, indexG2 = -1;
for (int i = 0; i < mBayerPattern.Length; i++)
{
if (mBayerPattern[i] == BayerColor.Green && indexG1 == -1)
{
indexG1 = i;
}
if (mBayerPattern[i] == BayerColor.Green && indexG1 != -1)
{
indexG2 = i;
}
}
float g1 = (float)blackPoint.Value[indexG1];
float g2 = (float)blackPoint.Value[indexG2];
mBlackLevel[1] = Math.Max(g1, g2); //well, one could distinguish the two greens, but what for?
}
}
mWhiteLevel = new float[] { whiteLevelAll, whiteLevelAll, whiteLevelAll };
mWhiteLevel[0] -= mBlackLevel[0];
mWhiteLevel[1] -= mBlackLevel[1];
mWhiteLevel[2] -= mBlackLevel[2];
float scale = scaling.Value;
mWhiteBalance = new float[] { whitePoint.Value[0] / scale, whitePoint.Value[1] / scale, whitePoint.Value[3] / scale };
if (makernote.Value.GetEntry <MNLevelInfo>() != null)
{
mRollAngle = makernote.Value.GetEntry <MNLevelInfo>().Value.RollAngle;
mRollAnglePresent = true;
}
mWidth = (int)raw.GetEntry <IFDImageWidth>().Value;
mHeight = (int)raw.GetEntry <IFDImageLength>().Value;
//look for orientation tag.
if (raw.GetEntry <IFDOrientation>() != null)
{
mOrientation = new DNGOrientation(raw.GetEntry <IFDOrientation>().Value);
}
else
{
//no tag found, use default
mOrientation = new DNGOrientation(DNGOrientation.Orientation.Normal);
}
//we always crop at least two pixels because of our algos...
mCropLeft = 2;
mCropTop = 2;
mCroppedWidth = mWidth - 4;
mCroppedHeight = mHeight - 4;
mMake = raw.GetEntry <IFDMake>().Value;
mUniqueModelName = raw.GetEntry <IFDModel>().Value;
//missing data, like noise model, crop area, etc..., must be loaded afterwards!
double[] colorMatrix = new double[] { 1, 0, 0, 0, 1, 0, 0, 0, 1 };
mColorSpec = new DNGColorSpec(colorMatrix, colorMatrix, IFDDNGCalibrationIlluminant.Illuminant.D50, IFDDNGCalibrationIlluminant.Illuminant.D50, mWhiteBalance);
return(raw);
}
private ImageFileDirectory SetMembers()
{
ImageFileDirectory rawIFD = null;
//find the IFD with the RAW Bayer image
for (int i = 0; i < mIfds.Count; i++)
{
//well, it should actually be somewhere in IFD0...
if (mIfds[i].GetEntry <IFDPhotometricInterpretation>() != null)
{
if (mIfds[i].GetEntry <IFDPhotometricInterpretation>().Value ==
IFDPhotometricInterpretation.PhotometricInterpretation.CFA)
{
rawIFD = mIfds[i];
break;
}
}
}
//no root IFD seems to contain RAW bayer, search for Sub-IFDs
if (rawIFD == null)
{
//find the IFD with the RAW Bayer image
for (int i = 0; i < mIfds.Count; i++)
{
IFDSubIFDs subIFD = mIfds[i].GetEntry <IFDSubIFDs>();
if (subIFD == null)
{
continue;
}
for (int j = 0; j < subIFD.Value.Count; j++)
{
if (subIFD.Value[j].GetEntry <IFDPhotometricInterpretation>().Value ==
IFDPhotometricInterpretation.PhotometricInterpretation.CFA)
{
rawIFD = subIFD.Value[j];
break;
}
}
}
}
if (rawIFD == null)
{
throw new ArgumentException("Can't find IFD with Bayer RAW image.");
}
mLinearizationTable = rawIFD.GetEntry <IFDDNGLinearizationTable>();
mWidth = (int)rawIFD.GetEntry <IFDImageWidth>().Value;
mHeight = (int)rawIFD.GetEntry <IFDImageLength>().Value;
if (mIfds[0].GetEntry <IFDDateTime>() != null)
{
mRecordingDate = mIfds[0].GetEntry <IFDDateTime>().Value;
}
//in case of Pentax this will have succes:
IFDDNGPrivateData privateData = mIfds[0].GetEntry <IFDDNGPrivateData>();
if (privateData != null)
{
MNLevelInfo levelInfo = privateData.PentaxMakerNotes.GetEntry <MNLevelInfo>();
if (levelInfo != null)
{
mRollAngle = levelInfo.Value.RollAngle;
mRollAnglePresent = true;
}
}
IFDExif exif = mIfds[0].GetEntry <IFDExif>();
if (exif != null)
{
mISO = exif.GetEntry <ExifISOSpeedRatings>().Value;
mExposureTime = exif.GetEntry <ExifExposureTime>().Value;
mRecordingDate = (exif.GetEntry <ExifDateTimeDigitized>()?.Value).GetValueOrDefault(mRecordingDate);
}
else if (rawIFD.GetEntry <IFDISOSpeedRatings>() != null)
{
mISO = rawIFD.GetEntry <IFDISOSpeedRatings>().Value;
//very likely that exposure time is also present
mExposureTime = rawIFD.GetEntry <IFDExposureTime>().Value;
}
else if (mIfds[0].GetEntry <IFDISOSpeedRatings>() != null)
{
mISO = mIfds[0].GetEntry <IFDISOSpeedRatings>().Value;
//very likely that exposure time is also present
mExposureTime = mIfds[0].GetEntry <IFDExposureTime>().Value;
}
mBitDepth = rawIFD.GetEntry <IFDBitsPerSample>().Value[0];
int bayerWidth = rawIFD.GetEntry <IFDCFARepeatPatternDim>().Value[0];
int bayerHeight = rawIFD.GetEntry <IFDCFARepeatPatternDim>().Value[1];
if (bayerHeight != 2 || bayerWidth != 2)
{
throw new ArgumentException("This file has a bayer pattern size different than 2x2. Can't decode that.");
}
ExifCFAPattern.BayerColor[] bayer = rawIFD.GetEntry <IFDCFAPattern>().Value;
mBayerPattern = new BayerColor[bayer.Length];
for (int i = 0; i < bayer.Length; i++)
{
mBayerPattern[i] = (BayerColor)(int)bayer[i];
}
IFDDNGCFAPlaneColor planeColor = rawIFD.GetEntry <IFDDNGCFAPlaneColor>();
int[] planeColorHelper = new int[] { 0, 1, 2 };
if (planeColor != null) //did it ever differ from 0,1,2?
{
//0 = red, 1 = gree, 2 = blue.
//The debayer algo creates images with plane order red/green/blue.
//If this order differs, we need to re-order the planes in order to
//have the color matrices correct.
//reset colorTwist matrix:
mColorTwist = new float[3, 4];
if (planeColor.Value.Length > 3 || planeColor.Value.Length < 3)
{
throw new ArgumentException("This image doesn't contain three color planes.");
}
for (int i = 0; i < planeColor.Value.Length; i++)
{
int color = planeColor.Value[i];
planeColorHelper[i] = color;
if (color > 2)
{
throw new ArgumentException("This image contains colors different than red/green/blue.");
}
mColorTwist[color, i] = 1;
if (color != i)
{
mColorTwistIsIdentity = false;
}
}
}
mColorSpec = new DNGColorSpec(3, mIfds[0], rawIFD);
IFDDNGWhiteLevel whiteLevel = rawIFD.GetEntry <IFDDNGWhiteLevel>();
IFDDNGBlackLevel blackLevel = rawIFD.GetEntry <IFDDNGBlackLevel>();
mBlackLevel = new float[3];
if (blackLevel != null)
{
//only one value for all colors
if (blackLevel.Value.Length == 1)
{
mBlackLevel[0] = (float)blackLevel.Value[0].Value;
mBlackLevel[1] = (float)blackLevel.Value[0].Value;
mBlackLevel[2] = (float)blackLevel.Value[0].Value;
}
//values per color channel
if (blackLevel.Value.Length == 3)
{
mBlackLevel[planeColorHelper[0]] = (float)blackLevel.Value[0].Value;
mBlackLevel[planeColorHelper[1]] = (float)blackLevel.Value[1].Value;
mBlackLevel[planeColorHelper[2]] = (float)blackLevel.Value[2].Value;
}
//values per color bayer pattern
if (blackLevel.Value.Length == 4)
{
//red
int indexR = -1;
for (int i = 0; i < mBayerPattern.Length; i++)
{
if (mBayerPattern[i] == BayerColor.Red)
{
indexR = i;
break;
}
}
mBlackLevel[0] = (float)blackLevel.Value[indexR].Value;
//blue
int indexB = -1;
for (int i = 0; i < mBayerPattern.Length; i++)
{
if (mBayerPattern[i] == BayerColor.Blue)
{
indexB = i;
break;
}
}
mBlackLevel[2] = (float)blackLevel.Value[indexB].Value;
//green, the two remaining indices
int indexG1 = -1, indexG2 = -1;
for (int i = 0; i < mBayerPattern.Length; i++)
{
if (mBayerPattern[i] == BayerColor.Green && indexG1 == -1)
{
indexG1 = i;
}
if (mBayerPattern[i] == BayerColor.Green && indexG1 != -1)
{
indexG2 = i;
}
}
float g1 = (float)blackLevel.Value[indexG1].Value;
float g2 = (float)blackLevel.Value[indexG2].Value;
mBlackLevel[1] = Math.Max(g1, g2); //well, one could distinguish the two greens, but what for?
}
}
mWhiteLevel = new float[3];
mWhiteLevel[0] = (float)whiteLevel.Value[0];
mWhiteLevel[1] = (float)whiteLevel.Value[0];
mWhiteLevel[2] = (float)whiteLevel.Value[0];
//subtract black level from white level
mWhiteLevel[0] -= mBlackLevel[0];
mWhiteLevel[1] -= mBlackLevel[1];
mWhiteLevel[2] -= mBlackLevel[2];
//get white balance from color spec
DNGVector wb = mColorSpec.CameraWhite;
mWhiteBalance = new float[3];
mWhiteBalance[planeColorHelper[0]] = 1.0f / (float)wb[0];
mWhiteBalance[planeColorHelper[1]] = 1.0f / (float)wb[1];
mWhiteBalance[planeColorHelper[2]] = 1.0f / (float)wb[2];
//look for orientation tag. If RAW ifd has the tag, choose that one
if (rawIFD.GetEntry <IFDOrientation>() != null)
{
mOrientation = new DNGOrientation(rawIFD.GetEntry <IFDOrientation>().Value);
}
else if (mIfds[0].GetEntry <IFDOrientation>() != null)
{
mOrientation = new DNGOrientation(mIfds[0].GetEntry <IFDOrientation>().Value);
}
else
{
//no tag found, use default
mOrientation = new DNGOrientation(DNGOrientation.Orientation.Normal);
}
//default Values:
int cropLeft = 0;
int cropTop = 0;
int croppedWidth = mWidth;
int croppedHeight = mHeight;
IFDDNGActiveArea activeArea = rawIFD.GetEntry <IFDDNGActiveArea>();
//if active area is defined:
if (activeArea != null)
{
int top, left, bottom, right;
top = (int)activeArea.Value[0];
left = (int)activeArea.Value[1];
bottom = (int)activeArea.Value[2];
right = (int)activeArea.Value[3];
cropLeft += left;
cropTop += top;
croppedWidth = right - left;
croppedHeight = bottom - top;
//CFA pattern is defined on active area. If top/left is uneven we need to shift the CFA pattern accordingly
if (top % 2 != 0)
{
BayerColor bayer0 = BayerPattern[0];
BayerColor bayer1 = BayerPattern[1];
BayerPattern[0] = BayerPattern[2];
BayerPattern[1] = BayerPattern[3];
BayerPattern[2] = bayer0;
BayerPattern[3] = bayer1;
}
if (left % 2 != 0)
{
BayerColor bayer0 = BayerPattern[0];
BayerColor bayer2 = BayerPattern[2];
BayerPattern[0] = BayerPattern[1];
BayerPattern[2] = BayerPattern[3];
BayerPattern[1] = bayer0;
BayerPattern[3] = bayer2;
}
}
IFDDNGDefaultCropOrigin cropOrigin = rawIFD.GetEntry <IFDDNGDefaultCropOrigin>();
IFDDNGDefaultCropSize cropSize = rawIFD.GetEntry <IFDDNGDefaultCropSize>();
if (cropOrigin != null && cropSize != null)
{
int top, left, width, height;
left = (int)(cropOrigin.Value[0].Value);
top = (int)(cropOrigin.Value[0].Value);
width = (int)(cropSize.Value[0].Value);
height = (int)(cropSize.Value[0].Value);
cropLeft += left;
cropTop += top;
croppedWidth = width;
croppedHeight = height;
}
//we always crop at least two pixels because of our algos...
mCropLeft = Math.Max(2, cropLeft);
mCropTop = Math.Max(2, cropTop);
mCroppedWidth = croppedWidth - Math.Max(0, (cropLeft + croppedWidth) - (mWidth - 2));
mCroppedHeight = croppedHeight - Math.Max(0, (cropTop + croppedHeight) - (mHeight - 2));
IFDDNGNoiseProfile noise = rawIFD.GetEntry <IFDDNGNoiseProfile>();
if (noise == null)
{
noise = mIfds[0].GetEntry <IFDDNGNoiseProfile>();
}
if (noise != null)
{
//if noise level is given for all channels,
//take the green one as it is usually scalled to one
if (noise.Value.Length > 2)
{
mNoiseModelAlpha = (float)noise.Value[planeColorHelper[1] * 2];
mNoiseModelBeta = (float)noise.Value[planeColorHelper[1] * 2 + 1];
}
else
{
mNoiseModelAlpha = (float)noise.Value[0];
mNoiseModelBeta = (float)noise.Value[1];
}
}
mMake = mIfds[0].GetEntry <IFDMake>().Value;
mUniqueModelName = mIfds[0].GetEntry <IFDDNGUniqueCameraModel>().Value;
return(rawIFD);
}