Reading RAW MAPIR images in MATLAB

Question

I have a raw image from the MAPIR NDVI Camera and want to load it in MATLAB and export the two bands needed (NIR, red edge) as tif.

According to the manufacturer, the NIR data is stored in the blue channel and the visible light (red edge) in the red channel, as 16 bit.

I tried reading the file with the code from "How can I read in a RAW image in MATLAB?" but it creates these fragments and i'm not sure why this is happening. Either i read the file wrong, or it is because of a lower resolution of the NIR channel.

Here is the link to the RAW image used.

Answer 1

Looks like the reason for the "fragments" is CFA (color filter array).
Pixels arrangement is like Bayer Mosaic as follows:

It isn't clear what is the CFA alignment.

You posted:

According to the manufacturer, the NIR data is stored in the blue channel and the visible light (red edge) in the red channel

But there are 4 possible combinations of Bayer alignment.
In Matlab demosaic function documentation combinations are referred as 'gbrg', 'grbg', 'bggr' and 'rggb'.

I don't know what is the most common alignment.
I can't say which channel supposed to be the "blue channel", and which is the "red channel". (all we know is they positioned diagonally).
I also couldn't find the alignment information in Google.

Since I couldn't tell which is which, I have extracted all 4 possible channels:

srcN = 4608; %Raw image width (number of columns).
srcM = 3456; %Raw image height (number of rows).

%Open raw image for reading.
f = fopen('2017_0321_134045_015.RAW', 'r');

%Read raw data into matrix I (use '*uint16' for keeping data in uint16 - no conversion to double).
I = fread(f, [srcN, srcM], '*uint16');

fclose(f);

%Transpose I, because RAW image format is row-major, and Matlab matrix format is column-major.
I = I';


%Assume Bayer mosaic sensor alignment.
%Seperate to mosaic components.
J1 = I(1:2:end, 1:2:end);
J2 = I(1:2:end, 2:2:end);
J3 = I(2:2:end, 1:2:end);
J4 = I(2:2:end, 2:2:end);

figure;imshow(J1);title('J1');
figure;imshow(J2);title('J2');
figure;imshow(J3);title('J3');
figure;imshow(J4);title('J4');

%Save all 4 images as tif
imwrite(J1, 'J1.tif');
imwrite(J2, 'J2.tif');
imwrite(J3, 'J3.tif');
imwrite(J4, 'J4.tif');

Here are the four images (shrank by a factor of x4):

J1:

J2:

J3:

J4:

---

Update:

Emotional_Cabbage posted the following reference image:

I tried to get the raw image to the reference, but I can't get it right.

I think the CFA alignment is:
J1 - Red color channel.
J2 and J3 - Monochromatic instead of green color channel.
J4 - NIR color channel.

Illustration:

I used the following processing code:

J = demosaic(I, 'rggb');
J = imadjust(J, [0.02, 0.98], [], 0.45); %Adjust image intensity, and use gamma value of 0.45
J(:,:,2) = J(:,:,2)*0.75; %Reduce the green by factor of 0.75
figure;imshow(J);

Result:

There is still some missing information for getting the right result...

Answer 2

Although you already have accepted another answer, I wanted to save the results of my efforts here in case other folk have similar problems. This code runs on a Mac or Linux, per original question.

////////////////////////////////////////////////////////////////////////////////
// raw2tif.c
// Mark Setchell
//
// Reads a RAW file from a MAPIR NDVI camera and converts it to a TIF
//
// Usage:
// raw2tif RAWfile result.tif
////////////////////////////////////////////////////////////////////////////////
#include <stdio.h>
#include <stdlib.h>
#include <inttypes.h>
#include <string.h>
#include "tiffio.h"

#define WIDTH   4608
#define HEIGHT  3456
#define RAW_BITSPERSAMPLE   8
#define RAW_SAMPLESPERPIXEL 2
#define TIF_BITSPERSAMPLE   8
#define TIF_SAMPLESPERPIXEL 3

int main(int argc,char* argv[])
{
   char ifilename[128];
   char ofilename[128];
   unsigned char inrow[WIDTH*RAW_BITSPERSAMPLE*RAW_SAMPLESPERPIXEL/8];
   FILE* in;

   // Check input and output file names supplied
   if(argc!=3){
      fprintf(stderr,"Usage: raw2tif RAWfile TIFfile");
      exit(EXIT_FAILURE);
   }

   // Pick up arguments - infile (RAW) and outfile (TIF)
   strcpy(ifilename,argv[1]);
   strcpy(ofilename,argv[2]);

   // Open input file
   in=fopen(ifilename,"rb");
   if(in==NULL){
      fprintf(stderr,"ERROR: Unable to open RAW input file");
      exit(EXIT_FAILURE);
   }

   // Open output file
   TIFF *tif= TIFFOpen(ofilename, "w");
   if(tif==NULL){
      fprintf(stderr,"ERROR: Unable to open output file");
      exit(EXIT_FAILURE);
   }

   // Set baseline tags
   TIFFSetField(tif,TIFFTAG_IMAGEWIDTH,WIDTH);
   TIFFSetField(tif,TIFFTAG_IMAGELENGTH,HEIGHT);
   TIFFSetField(tif,TIFFTAG_BITSPERSAMPLE,TIF_BITSPERSAMPLE);
   TIFFSetField(tif,TIFFTAG_SAMPLESPERPIXEL,TIF_SAMPLESPERPIXEL);
   TIFFSetField(tif,TIFFTAG_ORIENTATION,ORIENTATION_TOPLEFT);
   TIFFSetField(tif,TIFFTAG_COMPRESSION,COMPRESSION_LZW);
   TIFFSetField(tif,TIFFTAG_PLANARCONFIG,PLANARCONFIG_CONTIG);
   TIFFSetField(tif,TIFFTAG_PHOTOMETRIC,PHOTOMETRIC_MINISBLACK);

   uint32  rowsPerStrip;
   rowsPerStrip = HEIGHT;
   rowsPerStrip = TIFFDefaultStripSize(tif, rowsPerStrip);
   TIFFSetField(tif, TIFFTAG_ROWSPERSTRIP, rowsPerStrip);
   TIFFSetupStrips(tif);

   // Line buffer
   int scanlineSize = TIFFScanlineSize(tif);
   unsigned char* scanline = (unsigned char*) _TIFFmalloc(scanlineSize);

   // Iterate over rows of RAW file writing rows of TIF file
   for(int row=0;row<HEIGHT;row++)
   {
      if(fread(inrow,WIDTH*RAW_BITSPERSAMPLE*RAW_SAMPLESPERPIXEL/8,1,in)!=1){
         fprintf(stderr,"ERROR: Error reading input file at row %d\n",row);
         exit(EXIT_FAILURE);
      }
      // Following few lines need correcting when input file format is known
      unsigned char* ip=inrow;
      unsigned char* op=scanline;
      for(int col=0;col<WIDTH;col++){
         *op++=*ip++;  // Write RAW red to TIF red
         *op++=0;      // Set TIF green to 0
         *op++=*ip++;  // Write RAW NIR to TIF blue
      }
      if(TIFFWriteScanline(tif,scanline,row,0) != 1){
         fprintf(stderr,"ERROR: Error writing output file at row %d\n",row);
         exit(EXIT_FAILURE);
      }
   }

   // Clean up
   _TIFFfree(scanline);
   TIFFClose(tif);
}

A suitable Makefile is:

CC=clang -Wall -pedantic
TIF_INC=-I/usr/include -I/usr/local/include
TIF_LIB=-L/usr/lib -L/usr/local/lib -ltiff

raw2tif: raw2tif.c
    $(CC) raw2tif.c $(TIF_INC) $(TIF_LIB) -o raw2tif