>> Mcalibrator2

>> update_Mcalibrator2_html_docs

colorimeters{1}={'Photo Research PR-650','pr650',0};
colorimeters{2}={'KONICA-MINOLTA CS-100A','cs100a',0};
colorimeters{3}={'KONICA-MINOLTA CS-150','cs150',1};
colorimeters{4}={'Admesy Brontes-LL (64bit)','brontesLL',1};
colorimeters{5}={'Admesy Brontes-LL (32bit)','brontesLL32',1};
colorimeters{6}={'Cambridge Research Systems ColorCAL2 Win-USB','colorcal',1};
%colorimeters{7}={'Cambridge Research Systems ColorCAL2 (PTB, not tested)','colorcal2',1};
colorimeters{7}={'Cambridge Research Systems ColorCAL CDC (Virtual Port)','colorcalcdc',0};
colorimeters{8}={'Cambridge Research Systems OptiCal (not tested)','optical',0};
colorimeters{9}={'International Light IL1700','il1700',0};
colorimeters{10}={'Dummy Colorimeter (for Debug)','dummy_colorimeter',0};

classdef cs100a
  % a class to manipulate MINOLTA CS-100A from MATLAB through a serial port connection
  %
  % Created    : "2012-04-11 09:23:57 ban"
  % Last Update: "2016-09-13 18:19:02 ban"

  properties (Hidden) %(SetAccess = protected)
    portname='COM1'; % id of serial port to communicate with CS-100A
    rscom=[];  % serial port object
  end

  properties
    init_flg=0;
  end

  methods

    % constructor
    function obj=cs100a(port_name)
      if nargin==1 && ~isempty(port_name)
        obj.portname=port_name;
      end
    end

    % destructor
    function obj=delete(obj)
      if ~isempty(obj.rscom)
        fclose(obj.rscom);
        delete(obj.rscom);
        obj.rscom=[];
        obj.init_flg=0;
      end
    end

    % create/open a serial port connection to communicate with CS-100A
    function obj=gen_port(obj,port_name)
      if nargin>1 && ~isempty(port_name)
        obj.portname=port_name;
        obj.rscom=serial(obj.portname);
      elseif ~isempty(obj.portname)
        obj.rscom=serial(obj.portname);
      else
        error('set a name of serial port.');
      end

      set(obj.rscom,'DataBits',7,'BaudRate',4800,'Parity','even','StopBits',2,'Terminator','CR/LF');

      fopen(obj.rscom);

      % NEW for MATLAB R14
      % After initializing the serial port using FOPEN,
      % you should set the RTS and DTR pins to low using the following code:
      set (obj.rscom, 'DataTerminalReady' ,'off') ;
      set (obj.rscom, 'RequestToSend' ,'off') ;
      % and pause for some msec
      pause(0.3);

      % When the RTS and DTR pins are subsequently set high at any time using the following code,
      % the voltage at the pins will be as expected:
      set (obj.rscom, 'DataTerminalReady' ,'on') ;
      set (obj.rscom, 'RequestToSend' ,'on') ;

      obj.init_flg=1;
    end

    % reset a serial port connection
    function obj=reset_port(obj)
      fclose(obj.rscom);
      delete(obj.rscom);
      obj.rscom=[];
      obj.init_flg=0;
    end

    % initialize CS-100A
    function [obj,check,integtime]=initialize(obj,integtime)

      if isempty(obj.rscom), error('serial connection has not been established. run gen_port first.'); end

      % NOTICE 1
      %
      % First, you must confirm electric (electrical) power supply 'OFF'.
      % Then, press 'ON' button of the CS-100A, pushing 'F' key.
      % Check whether the character 'c' was shown on the bottom right corner of the CS-100A display.
      % Through these process, CS-100A will be set as bothway communications mode.

      % NOTICE 2
      % 'integtime' is a dummy variable to match the format with the other class.
      % It is not used in this function.

      fprintf(obj.rscom, 'MDS,07'); % Set Up Measurement Parameters.
      pause(0.1);

      % Checking setting parameters.
      results=fgets(obj.rscom);

      if ~strcmp(results(1:4),'OK00')
        disp('setup error. check CS-100A and cable connections.');
        return;
      end

      % Format -MDS
      %             'MDS,[][]'
      %               00 : MINOLTA Standard Calibration Mode
      %               01 : Optional Calibration Mode
      %               04 : Chromaticity Measurement Mode
      %               05 : Color Difference Measurement Mode
      %               06 : Measurement Response Time --- 100ms Fast Mode
      %               07 : Measurement Response Time --- 400ms Slow Mode

      % Error Check Command Description
      %               ER00 : Command Error, or Parameters Error
      %               ER11 : Memory Values Error
      %               ER20 : EEPROM Error
      %               ER30 : Battely Out Error

      fprintf(obj.rscom, 'MDS,04'); % Set Up Measurement Parameters.
      pause(0.1);

      % Checking setting parameters.
      results=fgets(obj.rscom);

      if strcmp(results(1:4),'OK00')
        check = 0;
      else
        check = 1;
      end
    end

    % measure CIE1931 xyY of the target
    function [qq,Y,x,y,obj]=measure(obj,integtime)

      if isempty(obj.rscom), error('serial connection has not been established. run gen_serial first.'); end
      if nargin<2 || isempty(integtime), integtime=500; end %#ok

      % NOTICE 1
      % Terminator (delimiter) should be CR/LF (CR+LF).
      % This terminator was set by CreateSerialObjectMINOL.

      % NOTICE 2
      % 'integtime' is a dummy variable to match the format with the other class.
      % It is not used in this function.

      fprintf(obj.rscom, 'MES'); % Measure Light Under Conditions defined by the 'MDS' command line.
      pause(0.1);

      % Format -MES
      %       output : normal
      %                   'OK00,+[][][][][][],+.[][][][],+.[][][][]'
      %                     notice : here, + may chage to -
      %              : luminance and chromaticity over the measurement range
      %                   'ER10'
      %              : chromaticity over the measurement range
      %                   'OK11,+[][][][][][],+.0000,+.0000'
      %                     notice : here, + may chage to -
      %              : luminance over the measurement range
      %                   'OK12,-999999,+.[][][][],+.[][][][]'
      %                     notice : here, + may chage to -
      %              : values are over the display or maasurement range
      %                   'ER12'
      %              : luminance under the masurement range
      %                   'OK13,+[][][][][][],+.[][][][],+.[][][][]'
      %                     notice : here, + may chage to -

      results=fscanf(obj.rscom);
      %if strcmp(results(1:4),'OK00')
        qq=0;
        Y=str2num(results(6:12)); %#ok
        x=str2num(results(14:19)); %#ok
        y=str2num(results(21:26)); %#ok
        return
      %end

      % numretry=1; qq=1;
      % while numretry<=5 && qq~=0
      %   numretry=numretry+1;
      %   if strcmp(results(1:4),'OK00')
      %     Y=str2num(results(6:12)); %#ok
      %     x=str2num(results(14:19)); %#ok
      %     y=str2num(results(21:26)); %#ok
      %     qq=0;
      %   else
      %     if strcmp(results(1:4),'OK12')
      %       fprintf(obj.rscom, 'MDS,06'); % fast mode
      %       fscanf(obj.rscom); % clear data
      %     elseif strcmp(results(1:4),'OK13')
      %       fprintf(obj.rscom, 'MDS,07'); % slow mode
      %       fscanf(obj.rscom); % clear data
      %     end
      %     pause(0.1);
      %     fprintf(obj.rscom, 'MES');
      %     pause(0.1);
      %     results=fscanf(obj.rscom);
      %   end
      % end
      %
      % if numretry>5
      %   Y=str2num(results(6:12)); %#ok
      %   x=str2num(results(14:19)); %#ok
      %   y=str2num(results(21:26)); %#ok
      % end

      % Descriptions
      % qq                  : Measurement quality code (OK00 = O.K.)
      % U                   : Unit of Measured Luminace, always 0 with CS-100A
      % Y                   : +(-)[][][][][][] 1931 CIE Y (units indicated by U)
      % x                   : +(-).[][][][] 1931 CIE x
      % y                   : +(-).[][][][] 1931 CIE y
    end

  end % methods

end % classdef cs100a

classdef brontesLL
  % a class to manipulate Admesy Brontes-LL from MATLAB on Windows OS via a USB port
  %
  % [methods]
  % brontesLL=brontesLL.gen_port('PORT')             : generate USB port to communicate with Brontes-LL
  % brontesLL=brontesLL.initialize(integration_time) : initialize measurement parameters
  % brontesLL=brontesLL.reset_port()                 : reset USB port connection
  % [qq,Y,x,y,brontesLL]=brontesLL.measure(integration_time) : measure CIE1931 xyY
  % command=brontesLL.write('command')               : send command to Brontes-LL through USB connection
  % results=brontesLL.read(number_of_bytes)          : read resutls etc from Brontes-LL through USB connection
  %
  % [requirement]
  % 1. NI-VISA (National Instruments) or lib_usb_win32 driver
  % 2. Admesy_sdk.zip distributed by Admesy, Netherlands
  %
  % [how to use]
  % To use this class on Windows OS with Admesy BrontesLL, please first install
  % Admesy SDK distributed by Admesy, Netherlands.
  % After installing the sdk, please copy three files below
  % ~/Admesy SDK/libraries/libusbtmc/bin/x64/libusbtmc_x64.dll
  % ~/Admesy SDK/libraries/libusbtmc/bin/x86/libusbtmc_x86.dll
  % ~/Admesy SDK/libraries/libusbtmc/include/libusbtmc.h
  % to the same directory with this class file.
  %
  % [license details about Admesy SDK]
  % Admesy SDK license agreement
  % By installing the Admesy SDK, you agree to the following terms.
  % 1) The Admesy SDK can be used freely with Admesy instruments with no limitations regarding installation.
  % 2) Use of this library with other brands instruments is not permitted.
  % 3) This library is not licensed to third parties without the use of Admesy Instruments.
  % 4) Distribution of the files is only permitted with Admesy instruments or demo software.
  % Distributions should always include this end-user license.
  % 5) Modifications/renaming of DLL's are not permitted.
  % 6) Functions that are exported but undocumented, are not supported.
  % 7) This Admesy License agreement does not contain any 3th party licenses such as Labview,NI-Visa
  %     or Microsoft Visual Studio. 3th party software may require a separate license agreement.
  % 8) Libusbtmc can be used in conjunction with libusb. This does not require a separate license.
  % 9) The library is not distributed with source code. It is not open source, but free to use.
  % 10) The Admesy colour SDK is developed for use on the Windows Operating system (XP32bit, Vista, Win7,
  %     Win8) and with general hardware in mind. Admesy does not guarantee full functionality on all operating
  %     systems/hardware. Admesy Instruments can be operated on Linux and Mac OSX or other Operating systems,
  %     but that is not supported by this SDK.
  % 11) This SDK and its components are free to use under above terms and may not be sold to 3rd parties.
  %
  %
  % Created    : "2012-10-29 05:28:07 ban"
  % Last Update: "2017-06-30 10:17:52 ban"

  properties (Hidden) %(SetAccess = protected);
    % id of USB port to communicate with Brontes-LL. This is a dummy variable to match with the other function
    portname='USB0::0x1781::0x0E98::00032::INSTR';
    rscom=[];  % serial port object. This is a dummy variable to match with the other function
    deviceID='';
    devicehandle=0;
    TIME_OUT=5000; % time out of the communication in msec
  end

  properties
    init_flg=0;
  end

  methods

    % constructor
    function obj=brontesLL(port_name)
      if ~libisloaded('usbtmc')
        if strfind(computer('arch'),'64') % if working on a 64-bit machine
          %notfound=loadlibrary('libusbtmc_x64.dll',@admesy_libusbtmc_matlab,'alias','usbtmc');
          notfound=loadlibrary('libusbtmc_x64.dll','libusbtmc.h','alias','usbtmc');
        else % if working on a 32-bit machine.
          %notfound=loadlibrary('libusbtmc_x86.dll',@admesy_libusbtmc_matlab,'alias','usbtmc');
          notfound=loadlibrary('libusbtmc_x86.dll','libusbtmc.h','alias','usbtmc');
        end
        if ~isempty(notfound)
          if strfind(computer('arch'),'64') % if working on a 64-bit machine
            error('library: libusbtmc_x64.dll & libusbtmc.h not found. check input variable.');
          else % if working on a 32-bit machine.
            error('library: libusbtmc_x86.dll & libusbtmc.h not found. check input variable.');
          end
        end
      end
      if nargin==1 && ~isempty(port_name)
        obj.portname=port_name;
      end
    end

    % destructor
    function obj=delete(obj)
      obj.rscom=[];
      obj.init_flg=0;
      if obj.devicehandle~=0, calllib('usbtmc','usbtmc_close',obj.devicehandle); end
      unloadlibrary('usbtmc');
    end

    % create/open a USB port connection to communicate with Brontes-LL
    function obj=gen_port(obj,port_name) %#ok
      % port_name is a dummy variable to match nargin with the other functions
      if obj.init_flg==1
        disp('USB connection with Brontes-LL is already established');
      else
        disp('starting USB communication with Brontes-LL');

        % find Brontes-LL device with its ID
        usbtmcdevices=libpointer('stringPtr',repmat(' ',1,255));
        [dummy,obj.deviceID]=calllib('usbtmc','usbtmc_find_devices',usbtmcdevices);
        clear usbtmcdevices;
        if obj.deviceID==0
          warning('USB communication can not be established. check cable connection'); %#ok
          obj.init_flg=0;
        else
          % open USB port
          [dummy,obj.deviceID,obj.devicehandle]=calllib('usbtmc','usbtmc_open',obj.deviceID,0);
          if obj.devicehandle==0
            error('USB port not opend. check cable connection');
          end
          obj.init_flg=1;
        end

      end
    end

    % reset a serial port connection
    function obj=reset_port(obj)
      obj.rscom=[];
      obj.init_flg=0;
      calllib('usbtmc','usbtmc_close',obj.devicehandle);
      obj.deviceID='';
      obj.devicehandle=0;
      [dummy,obj.deviceID,obj.devicehandle]=calllib('usbtmc','usbtmc_open',obj.deviceID,0);
    end

    % initialize Brontes-LL
    function [obj,check,integtime]=initialize(obj,integtime)
      if nargin<=2 || isempty(integtime), integtime=40000; end
      integtime=min(integtime,500000);
      integtime=max(5000,integtime);

      check=0;
      try
        % reset & clear the device
        [dummy,obj.devicehandle]=calllib('usbtmc','usbtmc_write',obj.devicehandle,':*RST',obj.TIME_OUT);
        [dummy,obj.devicehandle]=calllib('usbtmc','usbtmc_write',obj.devicehandle,':*CLS',obj.TIME_OUT);

        % set gain
        [dummy,obj.deviceID]=calllib('usbtmc','usbtmc_write',obj.devicehandle,':SENSE:GAIN 1',obj.TIME_OUT);

        % set num of samples to be averaged
        [dummy,obj.devicehandle]=calllib('usbtmc','usbtmc_write',obj.devicehandle,':SENSE:AVERAGE 10',obj.TIME_OUT);

        % set integration time in usec
        [dummy,obj.devicehandle]=calllib('usbtmc','usbtmc_write',obj.devicehandle,sprintf(':SENSE:INT %d',integtime),obj.TIME_OUT);

        % set sampling band width
        [dummy,obj.devicehandle]=calllib('usbtmc','usbtmc_write',obj.devicehandle,':SENSE:SBW small',obj.TIME_OUT);
      catch %#ok
        check=1;
      end
    end

    % measure CIE1931 xyY of the target
    function [qq,Y,x,y,obj]=measure(obj,integtime)

      if ~obj.init_flg, disp('initialization has not completed. open port and initialize the apparatus first.'); return; end
      if nargin<2 || isempty(integtime), integtime=20000*2; end
      integtime=min(integtime,500000);
      integtime=max(5000,integtime);

      qq=1; counter=0;
      while qq~=0 && counter<5
        counter=counter+1;
        if counter>2
          if qq>0
            integtime=min(ceil(integtime*0.8),5000);
          elseif qq<0
            integtime=min(ceil(integtime*1.2),5000000);
          end
          [dummy,obj.devicehandle]=calllib('usbtmc','usbtmc_write',obj.devicehandle,sprintf(':SENSE:INT %d',integtime),obj.TIME_OUT);
        end

        % [about output format of measured CIE1931 xyY]
        %
        % :MEASure command returns their result in ASCII formated floating point as shown below :
        % (Y,x,y,clip,noise) %f,%f,%f,%d,%d\n;
        %
        % The integration time setting can be varied from 0.5ms to 5s.
        % It is specified in microsecond. Results from the Brontes-LL colorimeter include a clip and noise
        % indication which indicate whether the measured light is too bright (clip) or too low (noise).
        % When clipping is detected, the resulting colour will not be correct and a lower integration time
        % should be chosen. When noise is detected, a larger integration time should be chosen.

        [dummy,obj.devicehandle]=calllib('usbtmc','usbtmc_write',obj.devicehandle,':meas:YXY',obj.TIME_OUT);
        bytecount=64;
        data_ptr=libpointer('uint8Ptr',zeros(1,bytecount));

        % [Note from Admesy SDK manual about the use of Bytecount]
        %
        % The third input variable of usbtmc_read is Bytecount.
        % The number of bytes that needs to be read may exceed the actual data that is available.
        % However, assigning always a very large number is discouraged.
        % For example when a ":meas:XYZ" command returns 36 bytes, you may ask for 64 bytes.
        % When you use a ":sample:Y" function, you know exactly how many bytes should be returned.
        % It is than best to input this exact number or just a little bit more.
        % In case you read for example 65535 bytes for a ":meas:XYZ: command, the internal library
        % allocates 65535 bytes where it only gets 36bytes back. This works, but is inefficient in
        % memory and execution time.

        [dummy,obj.devicehandle,measured]=calllib('usbtmc','usbtmc_read',obj.devicehandle,data_ptr,uint32(bytecount),obj.TIME_OUT);
        clear data_ptr;

        val=sscanf(char(measured),'%f,%f,%f,%d,%d\n');
        if sum(measured)~=0
          if numel(val)~=0
            Y=val(1);
            x=val(2);
            y=val(3);
            clip=val(4);
            noise=val(5);
            qq=0;
            %if clip, qq=1; end
            %if noise, qq=-1; end
            %if clip==0 && noise==0, qq=0; end
          else
            qq=1; Y=[]; x=[]; y=[];
          end
        else
          if numel(val)>4
            if val(4)==0
              warning('the measured light is too bright'); %#ok
            elseif val(5)==0
              warning('the measured light is too dark'); %#ok
            end
          else
            warning('measuring failed. check the cable connection'); %#ok
          end
          qq=1; Y=[]; x=[]; y=[];
        end
      end
    end

    % write command to Brontes-LL through USB connection
    function [obj,command]=write(obj,command)
      calllib('usbtmc','usbtmc_write',obj.devicehandle,command,obj.TIME_OUT);
    end

    % read results etc from Brontes-LL through USB connection
    function [obj,results]=read(obj,bytecount)
      if nargin<2 || ismepty(bytecount), bytecount=128; end
      data_ptr=libpointer('uint8Ptr',zeros(1,bytecount));
      [dummy,obj.devicehandle,results]=calllib('usbtmc','usbtmc_read',obj.devicehandle,data_ptr,uint32(bytecount),obj.TIME_OUT);
      results=char(results);
      clear data_ptr;
    end

  end % methods

end % classdef brontesLL

meas_methods{1}={'Measure simply','calculator_measure_simply'};
meas_methods{2}={'[auto] Recursive linear estimation with unifrnd()','calculator_auto_estimation_linear'};
meas_methods{3}={'[auto] Recursive linear estimation with Grid','calculator_auto_estimation_linear_grid'};
meas_methods{4}={'[auto] Adjust residuals by linear coefficients','calculator_auto_estimation_lincoeff'};
meas_methods{5}={'[auto] Non-linear (Nelder-Mead Simplex)','calculator_auto_estimation_nonlinear'};
meas_methods{6}={'[auto] Linear/non-linear hybrid','calculator_auto_estimation_hybrid'};
meas_methods{7}={'[auto] Brent-Powell with Coggins/Golden-section','calculator_auto_estimation_powell'};
meas_methods{8}={'[auto] Linear/Brent-Powell hybrid','calculator_auto_estimation_powell_hybrid'};

global config;             % a structure which stores configuration of Mcalibrator2
global colorimeterhandler; % an object to handle a colorimeter
global displayhandler;     % an object to present a chromaticity on display
global phosphers;          % CIE1931 xyY values of RGB phosphors at their maximum levels
global flares;             % Flares (zero-level luminance) of RGB phosphers

function [lut,xyY]=gamma_correction_ColorCAL(mes_steps,fit_method,num_repeats)

% A sample script to perform display gamma-correction by yourself without Mcalibrator2 GUI window.
% function [lut,xyY]=gamma_correction_ColorCAL(:mes_steps,:fit_method,:num_repeats)
% (: is optional)
%
% A simple script to perform display gamma-correction (grayscale only) using
% Cambridge Research Systems ColorCAL MK2 via a USB connection.
% When you customize the sub-routine to display color patches (DisplayColorWindow),
% you can interact with Psychtoolbox, ViSaGe, or BITS#.
%
% [how to use]
% 1. connect ColorCAL MK2 to computer with a USB cable
% 2. launch MATLAB (32-bit) and go to this directory
% 3. run the gamma-correction script on MATLAB
%    >> lut=gamma_correction_ColorCAL(32)
% 4. results is stored in 'gamma_correction_YYMMDD.mat' file
%
% [input]
% mes_steps   : measurement steps. 32 by default.
%               luminance measurement will be performed for video input values
%               defined by linspace(0.0,1.0,mes_steps)
% fit_method  : method to create gamma table, 'cbs' by default.
%               one of 'gog','cbs','rcbs','pow','pow2','log','lin', 'poly', 'sig', or 'sg'
%               currently, supported methods are
%               'gog'  : gain-offset-gamma model, exponential, based on CRT's internal model
%               'cbs'  : cubic spline
%               'rcbs' : robust cubic spline
%               'pow'  : power function
%               'pow2' : diff of 2 power functions
%               'log'  : 5th order polynomial fit in log space
%               'lin'  : linear interpolation
%               'poly' : 5th order polynomial fit
%               'sig'  : sigmoid function
%               'wbl'  : Weibull function
%               'gs'   : grid search with robust spline
%                        only valid when numluttbl==length(lum)
%               'gog (gain-offset-gamma model)' by default
%               'cbs (cubic spline)' is also recommneded if the display is LCD, DLP, or EL
%               For details, please see ApplyGammaCorrection.m
% num_repeats : the number of repetitions of the measurements, 1 by default.
%
% [output]
% lut        : the generated Color LookupTable. [1 x 256] matrix.
% xyY        : measured xyY values for each of video input intensities.
%              [4(video input value, x, y, Y) x mes_step] matrix.
%
%
% Created    : "2012-10-31 16:15:32 ban"
% Last Update: "2013-12-18 11:15:35 ban"

% check input variables
if nargin<1 || isempty(mes_steps), mes_steps=32; end
if nargin<2 || isempty(fit_method), fit_method='cbs'; end
if nargin<3 || isempty(num_repeats), num_repeats=1; end

% add path to Mcalibrator2 subfunctions
addpath(genpath(fullfile(pwd,'..','subfunctions')));

% generate directory to save the results
save_dir=fullfile(pwd,'results');
if ~exist(save_dir,'dir'), mkdir(save_dir); end

% initialize ColorCAL
device=colorcal;
device=device.gen_port();
device=device.initialize();

% display color window for adjusting colorimeter position
fullscr_flg=1;
fig_id=DisplayColorWindow(999,fullscr_flg);

disp(' ');
disp('*******************************************************************');
disp('adjust colorimeter position and press OK, then press F5 to proceed.');
disp('*******************************************************************');
disp(' ');
keyboard;

% set colors and mask
colors={'red','green','blue','gray'};
colormask={[1,0,0],[0,1,0],[0,0,1],[1,1,1]};

% initializing xyY data structure
xyY=cell(length(colors),1);
for ii=1:1:length(colors)
  xyY{ii}=zeros(4,mes_steps); % 4 = video-input-values, CIE1931 x, CIE1931 y, and CIE1931 Y.
  xyY{ii}(1,:)=linspace(0.0,1.0,mes_steps);
end

% light measurements, alternatively you can use MeasureCIE1931xyYs function implemented in Mcalibrator2.
for ii=1:1:length(colors)
  fprintf('measuring luminance/chromaticity for %s...',colors{ii});
  tmpx=zeros(num_repeats,mes_steps); tmpy=zeros(num_repeats,mes_steps); tmpY=zeros(num_repeats,mes_steps);
  for rr=1:1:num_repeats
    for nn=1:1:mes_steps
      fig_id=DisplayColorWindow(repmat(xyY{ii}(1,nn),1,3).*colormask{ii},fullscr_flg,fig_id);
      [dummy,tmpY(rr,nn),tmpx(rr,nn),tmpy(rr,nn),device]=device.measure();
    end
  end
  xyY{ii}(2:4,:)=[mean(tmpx,1);mean(tmpy,1);mean(tmpY,1)];
  clear tmpx tmpy tmpY;
  disp('done.');
end

% close color window and release a persistent variable to control figure
DisplayColorWindow(-999,fullscr_flg,fig_id);

% apply gamma-correction to the measured data
lutnum=256; monotonic_flg=1; lowpass_flg=0; flare_correction_flg=1; display_flg=1; save_flg=0;
lut=cell(length(colors),1);
for ii=1:1:length(colors)
  fprintf('generating gamma-table for %s...',colors{ii});
  lut{ii}=ApplyGammaCorrection(xyY{ii}([1,4],:),fit_method,lutnum,monotonic_flg,lowpass_flg,flare_correction_flg,display_flg,save_flg);
  movefile(fullfile(pwd,sprintf('gamma_corr_result_%s.png',fit_method)),...
           fullfile(save_dir,sprintf('gamma_corr_result_%s_%s.png',fit_method,colors{ii})));
  disp('done.');
end

% save phosphor xyY as [rx,gx,bx;ry,gy,by;rY,gY,bY]
phosphors=[xyY{1}(2:4,end),xyY{2}(2:4,end),xyY{3}(2:4,end)];

% save the measurement resutls
fprintf('saving the data...');
savefname=fullfile(save_dir,sprintf('gamma_correction_%s.mat',datestr(now,'yymmdd')));
save(savefname,'colors','colormask','lut','xyY','phosphors');
disp('done.');

% remove path to Mcalibrator2 subfunctions
rmpath(genpath(fullfile(pwd,'..','subfunctions')));

return

function estimate=auto_color_estimation_ColorCAL(xyY_want,lut,phosphors)

% A sample script to run the recursive-linear automatic color estimation by yourself without Mcalibrator2 GUI window.
% function estimate=auto_color_estimation_ColorCAL(xyY_want,lut,:phosphors)
% (: is optional)
%
% A simple script to run the recursive-linear automatic color estimation procedure developed
% by H.Ban and H.Yamamoto, using Cambridge Research Systems ColorCAL MK2 via a USB connection.
%
% The details of the algorithm is described in
% Ban, H., & Yamamoto, H. (2013).
% A non-device-specific approach to display characterization based on linear, nonlinear, and hybrid search algorithms.
% Journal of Vision, 13(6):20, 1-26, http://www.journalofvision.org/content/13/6/20, doi:10.1167/13.6.20.
%
% [how to use]
% 1. connect ColorCAL MK2 to computer with a USB cable
% 2. launch MATLAB (32-bit) and go to this directory
% 3. run the auto-calibration script on MATLAB
%    >> estimate=auto_color_estimation_ColorCAL(xyY_want,lut);
% 4. results is stored in 'auto_estimation_YYMMDD.mat' file
%
% [input]
% xyY_want   : xyY values we want, [3 x n] matrix
% lut        : color lookup table, [n x 3(r,g,b)] matrix, set lut=[]; if you do not need to use LUTs
% phosphors  : phosphor xyY, [rx,gx,bx;ry,gy,by;rY,gY,bY] (RGB) at max voltage level of the display
%
% [output]
% estimate   : cell structure {n x 1}, holding the estimation results with the variables below
%              .method --- 'LUT' or 'RGB
%              .wanted_xyY
%              .measured_xyY
%              .residuals --- measured_xyY minus rawxyY
%              .rms --- error
%              .RGB --- RGB values for all the estimations
%              .LUT --- lut index if .method='LUT'
%              .final_xyY --- the final estimation of xyY
%              .final_RGB --- the final estimation of RGB
%              .final_LUT --- the final estimation of LUT
%
%
% Created    : "2013-12-11 13:15:17 ban"
% Last Update: "2013-12-18 11:18:17 ban"

% check input variables
if nargin<3, help(mfilename()); return; end

if size(xyY_want,1)~=3, error('xyY_want shold be [3(x,y,Y) x n] matrix. check input variable.'); end
if size(lut,2)==1, lut=repmat(lut,1,3); end
if size(phosphors,1)~=3 || size(phosphors,2)~=3, error('phosphors should be [rx,gx,bx;ry,gy,by;rY,gY,bY](3 x 3) matrix. check input variable.'); end

% if lut is empty, generating a linear one
if isempty(lut), lut=repmat(linspace(0.0,1.0,256),[3,1])'; end

% add path to Mcalibrator2 subfunctions
addpath(genpath(fullfile(pwd,'..','subfunctions')));

% generate directory to save the results
save_dir=fullfile(pwd,'results');
if ~exist(save_dir,'dir'), mkdir(save_dir); end

% initialize ColorCAL
device=colorcal;
device=device.gen_port();
device=device.initialize();

% set display handler
displayhandler=@DisplayColorWindow;

% set options for the recursive linear estimation of RGB video inputs to produce your xyY values
options.iteration=5;
options.samples=18;
options.rsmerror=1; % percent error. the estimation will be terminated when the error is less than this value.
options.ss0=2.0; % search space, from ss0 to ss1
options.ss1=1.0;

% run the recursive linear estimation
% you can also select one from the other algorithms implemented in Mcalibrator2 or your own procedures.
fprintf('optimizing RGB video inputs to produce xyY you want...');
estimate=AutoColorEstimateLinear(xyY_want,xyY_want,phosphors,[],lut,device,displayhandler,options);
disp('done.');

% plotting
fprintf('Plotting estimated accuracies on the CIE1931 diagram...');
PlotCIE1931xy([],phosphors,-1,0,1);
for mm=1:1:size(xyY_want,2)
  hold on;
  PlotCIE1931xy(xyY_want(1:2,mm),phosphors,0,1,1,1);
  PlotCIE1931xy(estimate{mm}.final_xyY(1:2),phosphors,0,1,1,0);
end
disp('done.');

% save the measurement resutls
fprintf('saving the results...');
savefname=fullfile(save_dir,sprintf('auto_estimation_%s.mat',datestr(now,'yymmdd')));
save(savefname,'estimate');
disp('done.');

% remove path to Mcalibrator2 subfunctions
rmpath(genpath(fullfile(pwd,'..','subfunctions')));

return

function [Phosphor,white,flare,mcolors,mcolors_str]=measure_RGBphosphors_brontes(out_fname,integtime,nrepeat)

% A sample script to measure CIE1931 xyY for RGB video input values by yourself without Mcalibrator2 GUI window.
% function [Phosphor,white,flare,mcolors,mcolors_str]=measure_RGBphosphors_brontes(:out_fname,:integtime,:nrepeat)
% (: is optional)
%
% A simple script to measure RGB phosphor chromaticities (at the maximum voltage level)
% using Admesy brontes-LL photometer through a USB connection.
%
% [how to use]
% 1. connect Brontes-LL to computer with a USB cable
% 2. launch MATLAB (32-bit) and go to this directory
% 3. run the measurement script on MATLAB
%    >> measure_RGBphosphors_brontes('your_output_file_name')
% 4. results is stored in 'your_output_file_name' file
%
% [input]
% out_fname  : output file name, e.g. 'left_projector.mat', 'phosphor.mat' by default
% integtime  : integration time in usec, 20000 by default
% nrepeat    : the number of repetitions, 5 by default
%
% [output]
% Phosphor   : RGB phosphor xyY, 3x3 matrix. [Rx,Gx,Bx;Ry,Gy,By;RY,GY,BY]
% white      : CIE1931 xyY for white (RGB=[255,255,255]), [wx;wy;wY]
% flare      : CIE1931 xyY for black (RGB=[  0,  0,  0]), [kx;ky;kY]
% mcolors={[1,0,0],[0,1,0],[0,0,1],[1,1,1],[0,0,0]}; (fixed in this function for simplicity)
% mcolors_str={'red  ','green','blue ','white','black'}; (fixed in this function for simplicity)
%
% [note on chromaticity unit conversion]
%
% Once you get phosphor (and white & flare) matrix, you can convert RGB video input values
% to the corresponding CIE1931 xyY (XYZ, Lab, uv) chromaticity values.
% (To do chromatictiy unit conversion, add path to 'subfunction' directory first)
%
% For example, when the target pixel RGB values are RGB=[255,100,64],
%
% 1. to convert RGB pixel values to CIE1931 xyY
% >> xyY = RGB2xyY(RGB./255,Phosphor,[]); % recommended
% or
% >> xyY = RGB2xyY(RGB./255,Phosphor,flare);
%
% 2. to convert xyY to XYZ
% >> XYZ = xyY2XYZ(xyY);
%
% 3. to convert XYZ to Lab (using a Psychtoolbox function)
% >> Lab = lab=XYZToLab(XYZ,xyY2XYZ(white));
%
% 4. to convert xy to uv (using a Psychtoolbox function)
% >> xy = xyY(1:2);
% >> uv = xyTouv(xy,0);
%
%
% Created    : "2012-10-31 16:15:32 ban"
% Last Update: "2013-12-18 11:15:29 ban"

% check input variable
if nargin<1 || isempty(out_fname), out_fname='phosphor.mat'; end
if nargin<2 || isempty(integtime), integtime=20000; end
if nargin<3 || isempty(nrepeat), nrepeat=5; end

if ~strcmp(out_fname(end-3:end),'.mat'), out_fname=[out_fname,'.mat']; end

% add path to Mcalibrator2 subfunctions
addpath(genpath(fullfile(pwd,'..','subfunctions')));

% generate directory to save the results
save_dir=fullfile(pwd,'results');
if ~exist(save_dir,'dir'), mkdir(save_dir); end

% initialize Brontes-LL
device=brontesLL;
device=device.gen_port('USB0::0x1781::0x0E98::00032::INSTR');
device=device.initialize(integtime);

% display color window for adjusting colorimeter position
fullscr_flg=1;
fig_id=DisplayColorWindow(999,fullscr_flg);

disp(' ');
disp('*******************************************************************');
disp('adjust colorimeter position and press OK, then press F5 to proceed.');
disp('*******************************************************************');
disp(' ');
keyboard;

% measure RGB
mcolors={[1,0,0],[0,1,0],[0,0,1],[1,1,1],[0,0,0]};
mcolors_str={'red  ','green','blue ','white','black'};
Y=zeros(nrepeat,length(mcolors)); x=zeros(nrepeat,length(mcolors)); y=zeros(nrepeat,length(mcolors));
fprintf('\nmeasuring display chromaticities...\n\n');
for nn=1:1:nrepeat
  for cc=1:1:length(mcolors)
    fig_id=DisplayColorWindow(mcolors{cc},fullscr_flg,fig_id);
    [qq,Y(nn,cc),x(nn,cc),y(nn,cc),device]=device.measure(integtime);
  end
end

% display measured values
Y=mean(Y,1); x=mean(x,1); y=mean(y,1);
for cc=1:1:length(mcolors)
  fprintf('%s: CIE1931 xyY = (%f,%f,%f)\n',mcolors_str{cc},x(cc),y(cc),Y(cc));
end

% close color window and release a persistent variable to control figure
DisplayColorWindow(-999,fullscr_flg,fig_id);

% RGB phosphor chromaticity, [Rx Gx Bx; Ry Gy By; RY GY BY]
Phosphor=[x(1),x(2),x(3);y(1),y(2),y(3);Y(1),Y(2),Y(3)];

% plotting measured xy values in CIE1931 chromaticity diagram
new_fig_flg=1; tri_flg=1; color_flg=1; marker_type=1;
PlotCIE1931xy([x(4);y(4)],Phosphor,new_fig_flg,tri_flg,color_flg,marker_type);
white=[x(4);y(4);Y(4)];
flare=[x(5);y(5);Y(5)];

% save the measured resutls
fprintf('saving the results...');
save(fullfile(save_dir,out_fname),'Phosphor','white','flare','mcolors','mcolors_str');
disp('done.');

% remove path to Mcalibrator2 subfunctions
rmpath(genpath(fullfile(pwd,'..','subfunctions')));

return