paradigma 0.3.2__py3-none-any.whl → 0.4.0__py3-none-any.whl

paradigma/ppg/glob_functions/jsonlab/savejson.m

@@ -1,475 +0,0 @@
-function json=savejson(rootname,obj,varargin)
-%
-% json=savejson(rootname,obj,filename)
-%    or
-% json=savejson(rootname,obj,opt)
-% json=savejson(rootname,obj,'param1',value1,'param2',value2,...)
-%
-% convert a MATLAB object (cell, struct or array) into a JSON (JavaScript
-% Object Notation) string
-%
-% author: Qianqian Fang (fangq<at> nmr.mgh.harvard.edu)
-% created on 2011/09/09
-%
-% $Id: savejson.m 460 2015-01-03 00:30:45Z fangq $
-%
-% input:
-%      rootname: the name of the root-object, when set to '', the root name
-%        is ignored, however, when opt.ForceRootName is set to 1 (see below),
-%        the MATLAB variable name will be used as the root name.
-%      obj: a MATLAB object (array, cell, cell array, struct, struct array).
-%      filename: a string for the file name to save the output JSON data.
-%      opt: a struct for additional options, ignore to use default values.
-%        opt can have the following fields (first in [.|.] is the default)
-%
-%        opt.FileName [''|string]: a file name to save the output JSON data
-%        opt.FloatFormat ['%.10g'|string]: format to show each numeric element
-%                         of a 1D/2D array;
-%        opt.ArrayIndent [1|0]: if 1, output explicit data array with
-%                         precedent indentation; if 0, no indentation
-%        opt.ArrayToStruct[0|1]: when set to 0, savejson outputs 1D/2D
-%                         array in JSON array format; if sets to 1, an
-%                         array will be shown as a struct with fields
-%                         "_ArrayType_", "_ArraySize_" and "_ArrayData_"; for
-%                         sparse arrays, the non-zero elements will be
-%                         saved to _ArrayData_ field in triplet-format i.e.
-%                         (ix,iy,val) and "_ArrayIsSparse_" will be added
-%                         with a value of 1; for a complex array, the 
-%                         _ArrayData_ array will include two columns 
-%                         (4 for sparse) to record the real and imaginary 
-%                         parts, and also "_ArrayIsComplex_":1 is added. 
-%        opt.ParseLogical [0|1]: if this is set to 1, logical array elem
-%                         will use true/false rather than 1/0.
-%        opt.NoRowBracket [1|0]: if this is set to 1, arrays with a single
-%                         numerical element will be shown without a square
-%                         bracket, unless it is the root object; if 0, square
-%                         brackets are forced for any numerical arrays.
-%        opt.ForceRootName [0|1]: when set to 1 and rootname is empty, savejson
-%                         will use the name of the passed obj variable as the 
-%                         root object name; if obj is an expression and 
-%                         does not have a name, 'root' will be used; if this 
-%                         is set to 0 and rootname is empty, the root level 
-%                         will be merged down to the lower level.
-%        opt.Inf ['"$1_Inf_"'|string]: a customized regular expression pattern
-%                         to represent +/-Inf. The matched pattern is '([-+]*)Inf'
-%                         and $1 represents the sign. For those who want to use
-%                         1e999 to represent Inf, they can set opt.Inf to '$11e999'
-%        opt.NaN ['"_NaN_"'|string]: a customized regular expression pattern
-%                         to represent NaN
-%        opt.JSONP [''|string]: to generate a JSONP output (JSON with padding),
-%                         for example, if opt.JSONP='foo', the JSON data is
-%                         wrapped inside a function call as 'foo(...);'
-%        opt.UnpackHex [1|0]: conver the 0x[hex code] output by loadjson 
-%                         back to the string form
-%        opt.SaveBinary [0|1]: 1 - save the JSON file in binary mode; 0 - text mode.
-%        opt.Compact [0|1]: 1- out compact JSON format (remove all newlines and tabs)
-%
-%        opt can be replaced by a list of ('param',value) pairs. The param 
-%        string is equivallent to a field in opt and is case sensitive.
-% output:
-%      json: a string in the JSON format (see http://json.org)
-%
-% examples:
-%      jsonmesh=struct('MeshNode',[0 0 0;1 0 0;0 1 0;1 1 0;0 0 1;1 0 1;0 1 1;1 1 1],... 
-%               'MeshTetra',[1 2 4 8;1 3 4 8;1 2 6 8;1 5 6 8;1 5 7 8;1 3 7 8],...
-%               'MeshTri',[1 2 4;1 2 6;1 3 4;1 3 7;1 5 6;1 5 7;...
-%                          2 8 4;2 8 6;3 8 4;3 8 7;5 8 6;5 8 7],...
-%               'MeshCreator','FangQ','MeshTitle','T6 Cube',...
-%               'SpecialData',[nan, inf, -inf]);
-%      savejson('jmesh',jsonmesh)
-%      savejson('',jsonmesh,'ArrayIndent',0,'FloatFormat','\t%.5g')
-%
-% license:
-%     BSD or GPL version 3, see LICENSE_{BSD,GPLv3}.txt files for details
-%
-% -- this function is part of JSONLab toolbox (http://iso2mesh.sf.net/cgi-bin/index.cgi?jsonlab)
-%
-
-if(nargin==1)
-   varname=inputname(1);
-   obj=rootname;
-   if(isempty(varname)) 
-      varname='root';
-   end
-   rootname=varname;
-else
-   varname=inputname(2);
-end
-if(length(varargin)==1 && ischar(varargin{1}))
-   opt=struct('FileName',varargin{1});
-else
-   opt=varargin2struct(varargin{:});
-end
-opt.IsOctave=exist('OCTAVE_VERSION','builtin');
-rootisarray=0;
-rootlevel=1;
-forceroot=jsonopt('ForceRootName',0,opt);
-if((isnumeric(obj) || islogical(obj) || ischar(obj) || isstruct(obj) || iscell(obj)) && isempty(rootname) && forceroot==0)
-    rootisarray=1;
-    rootlevel=0;
-else
-    if(isempty(rootname))
-        rootname=varname;
-    end
-end
-if((isstruct(obj) || iscell(obj))&& isempty(rootname) && forceroot)
-    rootname='root';
-end
-
-whitespaces=struct('tab',sprintf('\t'),'newline',sprintf('\n'),'sep',sprintf(',\n'));
-if(jsonopt('Compact',0,opt)==1)
-    whitespaces=struct('tab','','newline','','sep',',');
-end
-if(~isfield(opt,'whitespaces_'))
-    opt.whitespaces_=whitespaces;
-end
-
-nl=whitespaces.newline;
-
-json=obj2json(rootname,obj,rootlevel,opt);
-if(rootisarray)
-    json=sprintf('%s%s',json,nl);
-else
-    json=sprintf('{%s%s%s}\n',nl,json,nl);
-end
-
-jsonp=jsonopt('JSONP','',opt);
-if(~isempty(jsonp))
-    json=sprintf('%s(%s);%s',jsonp,json,nl);
-end
-
-% save to a file if FileName is set, suggested by Patrick Rapin
-if(~isempty(jsonopt('FileName','',opt)))
-    if(jsonopt('SaveBinary',0,opt)==1)
-	    fid = fopen(opt.FileName, 'wb');
-	    fwrite(fid,json);
-    else
-	    fid = fopen(opt.FileName, 'wt');
-	    fwrite(fid,json,'char');
-    end
-    fclose(fid);
-end
-
-%%-------------------------------------------------------------------------
-function txt=obj2json(name,item,level,varargin)
-
-if(iscell(item))
-    txt=cell2json(name,item,level,varargin{:});
-elseif(isstruct(item))
-    txt=struct2json(name,item,level,varargin{:});
-elseif(ischar(item))
-    txt=str2json(name,item,level,varargin{:});
-else
-    txt=mat2json(name,item,level,varargin{:});
-end
-
-%%-------------------------------------------------------------------------
-function txt=cell2json(name,item,level,varargin)
-txt='';
-if(~iscell(item))
-        error('input is not a cell');
-end
-
-dim=size(item);
-if(ndims(squeeze(item))>2) % for 3D or higher dimensions, flatten to 2D for now
-    item=reshape(item,dim(1),numel(item)/dim(1));
-    dim=size(item);
-end
-len=numel(item);
-ws=jsonopt('whitespaces_',struct('tab',sprintf('\t'),'newline',sprintf('\n'),'sep',sprintf(',\n')),varargin{:});
-padding0=repmat(ws.tab,1,level);
-padding2=repmat(ws.tab,1,level+1);
-nl=ws.newline;
-if(len>1)
-    if(~isempty(name))
-        txt=sprintf('%s"%s": [%s',padding0, checkname(name,varargin{:}),nl); name=''; 
-    else
-        txt=sprintf('%s[%s',padding0,nl); 
-    end
-elseif(len==0)
-    if(~isempty(name))
-        txt=sprintf('%s"%s": []',padding0, checkname(name,varargin{:})); name=''; 
-    else
-        txt=sprintf('%s[]',padding0); 
-    end
-end
-for j=1:dim(2)
-    if(dim(1)>1) txt=sprintf('%s%s[%s',txt,padding2,nl); end
-    for i=1:dim(1)
-       txt=sprintf('%s%s',txt,obj2json(name,item{i,j},level+(dim(1)>1)+1,varargin{:}));
-       if(i<dim(1)) txt=sprintf('%s%s',txt,sprintf(',%s',nl)); end
-    end
-    if(dim(1)>1) txt=sprintf('%s%s%s]',txt,nl,padding2); end
-    if(j<dim(2)) txt=sprintf('%s%s',txt,sprintf(',%s',nl)); end
-    %if(j==dim(2)) txt=sprintf('%s%s',txt,sprintf(',%s',nl)); end
-end
-if(len>1) txt=sprintf('%s%s%s]',txt,nl,padding0); end
-
-%%-------------------------------------------------------------------------
-function txt=struct2json(name,item,level,varargin)
-txt='';
-if(~isstruct(item))
-	error('input is not a struct');
-end
-dim=size(item);
-if(ndims(squeeze(item))>2) % for 3D or higher dimensions, flatten to 2D for now
-    item=reshape(item,dim(1),numel(item)/dim(1));
-    dim=size(item);
-end
-len=numel(item);
-ws=struct('tab',sprintf('\t'),'newline',sprintf('\n'));
-ws=jsonopt('whitespaces_',ws,varargin{:});
-padding0=repmat(ws.tab,1,level);
-padding2=repmat(ws.tab,1,level+1);
-padding1=repmat(ws.tab,1,level+(dim(1)>1)+(len>1));
-nl=ws.newline;
-
-if(~isempty(name)) 
-    if(len>1) txt=sprintf('%s"%s": [%s',padding0,checkname(name,varargin{:}),nl); end
-else
-    if(len>1) txt=sprintf('%s[%s',padding0,nl); end
-end
-for j=1:dim(2)
-  if(dim(1)>1) txt=sprintf('%s%s[%s',txt,padding2,nl); end
-  for i=1:dim(1)
-    names = fieldnames(item(i,j));
-    if(~isempty(name) && len==1)
-        txt=sprintf('%s%s"%s": {%s',txt,padding1, checkname(name,varargin{:}),nl); 
-    else
-        txt=sprintf('%s%s{%s',txt,padding1,nl); 
-    end
-    if(~isempty(names))
-      for e=1:length(names)
-	    txt=sprintf('%s%s',txt,obj2json(names{e},getfield(item(i,j),...
-             names{e}),level+(dim(1)>1)+1+(len>1),varargin{:}));
-        if(e<length(names)) txt=sprintf('%s%s',txt,','); end
-        txt=sprintf('%s%s',txt,nl);
-      end
-    end
-    txt=sprintf('%s%s}',txt,padding1);
-    if(i<dim(1)) txt=sprintf('%s%s',txt,sprintf(',%s',nl)); end
-  end
-  if(dim(1)>1) txt=sprintf('%s%s%s]',txt,nl,padding2); end
-  if(j<dim(2)) txt=sprintf('%s%s',txt,sprintf(',%s',nl)); end
-end
-if(len>1) txt=sprintf('%s%s%s]',txt,nl,padding0); end
-
-%%-------------------------------------------------------------------------
-function txt=str2json(name,item,level,varargin)
-txt='';
-if(~ischar(item))
-        error('input is not a string');
-end
-item=reshape(item, max(size(item),[1 0]));
-len=size(item,1);
-ws=struct('tab',sprintf('\t'),'newline',sprintf('\n'),'sep',sprintf(',\n'));
-ws=jsonopt('whitespaces_',ws,varargin{:});
-padding1=repmat(ws.tab,1,level);
-padding0=repmat(ws.tab,1,level+1);
-nl=ws.newline;
-sep=ws.sep;
-
-if(~isempty(name)) 
-    if(len>1) txt=sprintf('%s"%s": [%s',padding1,checkname(name,varargin{:}),nl); end
-else
-    if(len>1) txt=sprintf('%s[%s',padding1,nl); end
-end
-isoct=jsonopt('IsOctave',0,varargin{:});
-for e=1:len
-    if(isoct)
-        val=regexprep(item(e,:),'\\','\\');
-        val=regexprep(val,'"','\"');
-        val=regexprep(val,'^"','\"');
-    else
-        val=regexprep(item(e,:),'\\','\\\\');
-        val=regexprep(val,'"','\\"');
-        val=regexprep(val,'^"','\\"');
-    end
-    val=escapejsonstring(val);
-    if(len==1)
-        obj=['"' checkname(name,varargin{:}) '": ' '"',val,'"'];
-	if(isempty(name)) obj=['"',val,'"']; end
-        txt=sprintf('%s%s%s%s',txt,padding1,obj);
-    else
-        txt=sprintf('%s%s%s%s',txt,padding0,['"',val,'"']);
-    end
-    if(e==len) sep=''; end
-    txt=sprintf('%s%s',txt,sep);
-end
-if(len>1) txt=sprintf('%s%s%s%s',txt,nl,padding1,']'); end
-
-%%-------------------------------------------------------------------------
-function txt=mat2json(name,item,level,varargin)
-if(~isnumeric(item) && ~islogical(item))
-        error('input is not an array');
-end
-ws=struct('tab',sprintf('\t'),'newline',sprintf('\n'),'sep',sprintf(',\n'));
-ws=jsonopt('whitespaces_',ws,varargin{:});
-padding1=repmat(ws.tab,1,level);
-padding0=repmat(ws.tab,1,level+1);
-nl=ws.newline;
-sep=ws.sep;
-
-if(length(size(item))>2 || issparse(item) || ~isreal(item) || ...
-   isempty(item) ||jsonopt('ArrayToStruct',0,varargin{:}))
-    if(isempty(name))
-    	txt=sprintf('%s{%s%s"_ArrayType_": "%s",%s%s"_ArraySize_": %s,%s',...
-              padding1,nl,padding0,class(item),nl,padding0,regexprep(mat2str(size(item)),'\s+',','),nl);
-    else
-    	txt=sprintf('%s"%s": {%s%s"_ArrayType_": "%s",%s%s"_ArraySize_": %s,%s',...
-              padding1,checkname(name,varargin{:}),nl,padding0,class(item),nl,padding0,regexprep(mat2str(size(item)),'\s+',','),nl);
-    end
-else
-    if(numel(item)==1 && jsonopt('NoRowBracket',1,varargin{:})==1 && level>0)
-        numtxt=regexprep(regexprep(matdata2json(item,level+1,varargin{:}),'^\[',''),']','');
-    else
-        numtxt=matdata2json(item,level+1,varargin{:});
-    end
-    if(isempty(name))
-    	txt=sprintf('%s%s',padding1,numtxt);
-    else
-        if(numel(item)==1 && jsonopt('NoRowBracket',1,varargin{:})==1)
-           	txt=sprintf('%s"%s": %s',padding1,checkname(name,varargin{:}),numtxt);
-        else
-    	    txt=sprintf('%s"%s": %s',padding1,checkname(name,varargin{:}),numtxt);
-        end
-    end
-    return;
-end
-dataformat='%s%s%s%s%s';
-
-if(issparse(item))
-    [ix,iy]=find(item);
-    data=full(item(find(item)));
-    if(~isreal(item))
-       data=[real(data(:)),imag(data(:))];
-       if(size(item,1)==1)
-           % Kludge to have data's 'transposedness' match item's.
-           % (Necessary for complex row vector handling below.)
-           data=data';
-       end
-       txt=sprintf(dataformat,txt,padding0,'"_ArrayIsComplex_": ','1', sep);
-    end
-    txt=sprintf(dataformat,txt,padding0,'"_ArrayIsSparse_": ','1', sep);
-    if(size(item,1)==1)
-        % Row vector, store only column indices.
-        txt=sprintf(dataformat,txt,padding0,'"_ArrayData_": ',...
-           matdata2json([iy(:),data'],level+2,varargin{:}), nl);
-    elseif(size(item,2)==1)
-        % Column vector, store only row indices.
-        txt=sprintf(dataformat,txt,padding0,'"_ArrayData_": ',...
-           matdata2json([ix,data],level+2,varargin{:}), nl);
-    else
-        % General case, store row and column indices.
-        txt=sprintf(dataformat,txt,padding0,'"_ArrayData_": ',...
-           matdata2json([ix,iy,data],level+2,varargin{:}), nl);
-    end
-else
-    if(isreal(item))
-        txt=sprintf(dataformat,txt,padding0,'"_ArrayData_": ',...
-            matdata2json(item(:)',level+2,varargin{:}), nl);
-    else
-        txt=sprintf(dataformat,txt,padding0,'"_ArrayIsComplex_": ','1', sep);
-        txt=sprintf(dataformat,txt,padding0,'"_ArrayData_": ',...
-            matdata2json([real(item(:)) imag(item(:))],level+2,varargin{:}), nl);
-    end
-end
-txt=sprintf('%s%s%s',txt,padding1,'}');
-
-%%-------------------------------------------------------------------------
-function txt=matdata2json(mat,level,varargin)
-
-ws=struct('tab',sprintf('\t'),'newline',sprintf('\n'),'sep',sprintf(',\n'));
-ws=jsonopt('whitespaces_',ws,varargin{:});
-tab=ws.tab;
-nl=ws.newline;
-
-if(size(mat,1)==1)
-    pre='';
-    post='';
-    level=level-1;
-else
-    pre=sprintf('[%s',nl);
-    post=sprintf('%s%s]',nl,repmat(tab,1,level-1));
-end
-
-if(isempty(mat))
-    txt='null';
-    return;
-end
-floatformat=jsonopt('FloatFormat','%.10g',varargin{:});
-%if(numel(mat)>1)
-    formatstr=['[' repmat([floatformat ','],1,size(mat,2)-1) [floatformat sprintf('],%s',nl)]];
-%else
-%    formatstr=[repmat([floatformat ','],1,size(mat,2)-1) [floatformat sprintf(',\n')]];
-%end
-
-if(nargin>=2 && size(mat,1)>1 && jsonopt('ArrayIndent',1,varargin{:})==1)
-    formatstr=[repmat(tab,1,level) formatstr];
-end
-
-txt=sprintf(formatstr,mat');
-txt(end-length(nl):end)=[];
-if(islogical(mat) && jsonopt('ParseLogical',0,varargin{:})==1)
-   txt=regexprep(txt,'1','true');
-   txt=regexprep(txt,'0','false');
-end
-%txt=regexprep(mat2str(mat),'\s+',',');
-%txt=regexprep(txt,';',sprintf('],\n['));
-% if(nargin>=2 && size(mat,1)>1)
-%     txt=regexprep(txt,'\[',[repmat(sprintf('\t'),1,level) '[']);
-% end
-txt=[pre txt post];
-if(any(isinf(mat(:))))
-    txt=regexprep(txt,'([-+]*)Inf',jsonopt('Inf','"$1_Inf_"',varargin{:}));
-end
-if(any(isnan(mat(:))))
-    txt=regexprep(txt,'NaN',jsonopt('NaN','"_NaN_"',varargin{:}));
-end
-
-%%-------------------------------------------------------------------------
-function newname=checkname(name,varargin)
-isunpack=jsonopt('UnpackHex',1,varargin{:});
-newname=name;
-if(isempty(regexp(name,'0x([0-9a-fA-F]+)_','once')))
-    return
-end
-if(isunpack)
-    isoct=jsonopt('IsOctave',0,varargin{:});
-    if(~isoct)
-        newname=regexprep(name,'(^x|_){1}0x([0-9a-fA-F]+)_','${native2unicode(hex2dec($2))}');
-    else
-        pos=regexp(name,'(^x|_){1}0x([0-9a-fA-F]+)_','start');
-        pend=regexp(name,'(^x|_){1}0x([0-9a-fA-F]+)_','end');
-        if(isempty(pos)) return; end
-        str0=name;
-        pos0=[0 pend(:)' length(name)];
-        newname='';
-        for i=1:length(pos)
-            newname=[newname str0(pos0(i)+1:pos(i)-1) char(hex2dec(str0(pos(i)+3:pend(i)-1)))];
-        end
-        if(pos(end)~=length(name))
-            newname=[newname str0(pos0(end-1)+1:pos0(end))];
-        end
-    end
-end
-
-%%-------------------------------------------------------------------------
-function newstr=escapejsonstring(str)
-newstr=str;
-isoct=exist('OCTAVE_VERSION','builtin');
-if(isoct)
-   vv=sscanf(OCTAVE_VERSION,'%f');
-   if(vv(1)>=3.8) isoct=0; end
-end
-if(isoct)
-  escapechars={'\a','\f','\n','\r','\t','\v'};
-  for i=1:length(escapechars);
-    newstr=regexprep(newstr,escapechars{i},escapechars{i});
-  end
-else
-  escapechars={'\a','\b','\f','\n','\r','\t','\v'};
-  for i=1:length(escapechars);
-    newstr=regexprep(newstr,escapechars{i},regexprep(escapechars{i},'\\','\\\\'));
-  end
-end