Home > Codi > DATA.m

DATA

PURPOSE ^

SYNOPSIS ^

This is a script file.

DESCRIPTION ^

CROSS-REFERENCE INFORMATION ^

This function calls: This function is called by:

SUBFUNCTIONS ^

SOURCE CODE ^

0001 classdef (ConstructOnLoad = true) DATA < handle % Amb <handle estem heredant de handle i totes lesinstancies de DATA es passaran per referencia
0002     %La classe DATA es l'encarregada de muntar tota l'estructura de dades
0003     %necessaria per ferr PCA i posteriorment, si es bol, CBA.
0004     %Dins aquest Objecte, podem trobar, des de les dades originals de
0005     %l'objecte guardades en 3D fins a metodes per passar-les a 2D
0006     %utilitzant metodes de bach wide o variable wide.
0007     %
0008     %Les dades mes importants emmagatzemades en aquest objecte podem dir
0009     %que són:
0010     %
0011     %       nom -   Eel nom del proçes emmagatzemat
0012     %
0013     %       t_inici ¬
0014     %       t_fi   -|
0015     %       t_inc  _|- Aquests 3 parametres han de contenir els timmings
0016     %               del proces. Sent temps d'inici,fi i increment de temps
0017     %               entre mostres.
0018     %
0019     %       variables- Aqui és on es guarda el nom de les diferents
0020     %               variables, per facilitar el seu maneig aquest camp sera
0021     %               un vector de cell que contenen text amb el nom de les
0022     %               variables. Aquest camp es necessari i a més es
0023     %               important que el seu tamany sigui coerent amb el de les
0024     %               dades.
0025     %
0026     %       fases - Aqui és on es guarda el nom de les diferents fases del
0027     %               proces. Aquest camp tambe sera un vector de cell.
0028     %
0029     %       durafases-Aqui s'ha d'indicar la duració de les diferents fases
0030     %               del proces.
0031     %
0032     %       lots - Aqui es guardara el nombre de lots que te el proces, si
0033     %               s'entren les dades ja sigui BW , VB o 3D s'ha de tenir
0034     %               en compte que aquest parametre s'actualitzara sol.
0035     %               Tambe es pot fixar manualment si fos necessarli.
0036     %
0037     %       data - Aqui és guarden les dades del proces en format 3D
0038     %
0039     %       class - Es on es guarda la classe de cada batch en format
0040     %               numeric 1 ... n
0041     %
0042     %       nomclass - Aqui es guarda l'equivalencia, si cal, de la classe
0043     %               numerica amb el seu text corresponent.
0044     %
0045     
0046 %-------------------------------------------------------------------------%
0047 %% ----------------------------- VARIABLES -------------------------------
0048 %-------------------------------------------------------------------------%
0049     properties (Access = private) %Per defecte son privats posar (Access = public),(SetObservable = true),(SetObservable = false),(Access = private) segons les nostres necesitats
0050         % Propietats privades del nostre objecte
0051         nom; %nom del proces - nomes s'hi pot posar texte - no importa si no esta inicialitzat
0052         variables; % sera un vector de cell
0053         fases;%nom de la fase
0054         durafases;%[100 20 50 30] 4 fases i 100 20 50 30 mostres cada una
0055         lots;%1 si no es una Matriu 3D
0056         reflot;%sera el nom de cada lot
0057         data;%dades
0058         class;%numero de classe 1...N
0059     end
0060     
0061 %-------------------------------------------------------------------------%
0062 %% ----------------- DEFINICIO DE METODES DE LA CLASSE --------------------
0063 %-------------------------------------------------------------------------%
0064     methods%Els metodes son publics per defecte
0065         
0066 %-------------------------------------------------------------------------%
0067 %% -------------------------- CONSTRUCTORS --------------------------------
0068 %-------------------------------------------------------------------------%
0069         %constructor per defecte
0070         function obj =DATA()
0071             %El constructor per defecte: Aquest es el metode constructor
0072             %de l'objecte DATA. Per defecte es fixen  tots els valors a
0073             %null esperant que l'usuari entri les dades que realment hi han
0074             %d'anar, podriem dir que nomes reservem l'espai per l'objecte.
0075             %Les dades s'inicialitzen a -1 per poder identificar facilment
0076             %si hi ha hagut algun errors inicialitzant-les.
0077             %Parametres d'entrada:
0078             %
0079             %   Aquest metode no te cap parametre d'entrada
0080             %
0081             %Parametres de sortida:
0082             %
0083             %   obj - Retorna un objecte DATA inicialitzat per defecte
0084             %
0085             
0086             %DADES
0087             obj.nom=[];
0088             obj.fases=[];
0089             obj.durafases=[];
0090             obj.lots=0;%1 si no es una Matriu 3D <- posem a 0 per evitar problemes si ajunten un obj buit amb un de ple
0091             obj.reflot={};
0092             obj.data=[];%dades
0093             obj.class=[];
0094         end
0095         
0096         %funció per fer copies de la nostra estructura
0097         function copy = copy(obj)
0098             % Aquest constructor farà una copia del nostre objecte i la
0099             %retorna per referencia. No es diu com la classe ja que el
0100             %Matlab no permet el sobrecarregament de metodes d'un objecte.
0101             %
0102             %Parametres d'entrada:
0103             %
0104             %   Aquest metode no te cap parametre d'entrada
0105             %
0106             %Parametres de sortida:
0107             %
0108             %   copy - Es un objecte DATA, copia de l'actual.
0109             %
0110             copy = eval(class(obj));
0111             meta = eval(['?',class(obj)]);
0112             for p = 1: size(meta.Properties,1)
0113                 pname = meta.Properties{p}.Name;
0114                 try
0115                     eval(['copy.',pname,' = obj.',pname,';']);
0116                 catch exeption
0117                     %hi ha agut algun error, en mostrem el numero i el
0118                     %que implica.
0119                     fprintf('\nERROR: ');
0120                     fprintf(exeption);
0121                     fprintf(['\nDades/Copy: Could not copy ',pname,'.\n']);
0122                 end
0123             end
0124         end
0125 
0126         
0127 %-------------------------------------------------------------------------%
0128 %% ------------------ GETTERS, SETTERS & ALTRES ---------------------------
0129 %-------------------------------------------------------------------------%
0130 
0131         %% ->nom
0132         function setName(obj,nom)
0133             %fixa el nom, ha de ser de tipus char
0134             %
0135             %Parametres d'entrada:
0136             %
0137             %   nom - És el nou nom de l'objecte
0138             %
0139             %Parametres de sortida:
0140             %
0141             %   Aquest metode no te cap parametre de sortida
0142             %
0143             
0144             %mirem si te el format correcte
0145             z=whos('nom');
0146             if(strcmp( z.class , 'char'))
0147                 obj.nom = nom;%actualitzem l'objecte
0148             else
0149                 error('DATA/setName: nom must be char type')
0150             end
0151         end
0152         function obji = getName(obj)
0153             %Retorna el nom
0154             %
0155             %Parametres d'entrada:
0156             %
0157             %   Aquest metode no te cap parametre d'entrada
0158             %
0159             %Parametres de sortida:
0160             %
0161             %   obji - retorna el que l'usuari hagi entrat com a nom
0162             %
0163             
0164             obji = obj.nom;
0165         end
0166         
0167         %% ->Dimensions
0168         function obji = getBatchCount(obj)
0169             %Retorna el numero de lots de les nostres dades
0170             %
0171             %Parametres d'entrada:
0172             %
0173             %   Aquest metode no te cap parametre d'entrada
0174             %
0175             %Parametres de sortida:
0176             %
0177             %   obji - es un double, correspon al nombre de lots del nostre
0178             %         objecte
0179             %
0180             
0181             obji = obj.lots;%tornem els lots
0182         end
0183         function num = getVariableCount(obj)
0184             %Retorna el numero de variables de les nostres dades
0185             %
0186             %Parametres d'entrada:
0187             %
0188             %   Aquest metode no te cap parametre d'entrada
0189             %
0190             %Parametres de sortida:
0191             %
0192             %   num - es un double, correspon al nombre de variables del
0193             %         nostre objecte
0194             %
0195             
0196             if(isempty(obj.data))%si no tenim dades tornem numero de variables 0
0197                 num=0;
0198             else
0199                 num = size(obj.data,2);%el calculem
0200             end
0201         end
0202         function num = getSampleCount(obj)
0203             %Retorna el numero de instants de temps de les nostres dades
0204             %
0205             %Parametres d'entrada:
0206             %
0207             %   Aquest metode no te cap parametre d'entrada
0208             %
0209             %Parametres de sortida:
0210             %
0211             %   num - es un double, correspon al nombre de instants de
0212             %         temps del nostre objecte
0213             %
0214             if(isempty(obj.data)) %si no hi ha dades tornem 0
0215                 num=0;
0216             else
0217                 num = size(obj.data,1);%el calculem
0218             end
0219         end
0220         
0221         %% ->variables
0222         function setVariableLabel(obj,variables)
0223             %Fixara els noms de les variables. Aquests son els noms de les
0224             %diferents variables, se n'ha d'entra 1 per variable a poder
0225             %ser en el mateix ordre que els teim a les dades si no l'usuari
0226             %es podria confondre
0227             %
0228             %Parametres d'entrada:
0229             %
0230             %   variables - És el nou vector de noms de les variables.
0231             %               Aquest vector ha de ser una cellstring
0232             %
0233             %Parametres de sortida:
0234             %
0235             %   Aquest metode no te cap parametre de sortida
0236             %
0237             
0238             %primer comprobem que ens han passat
0239             z=whos('variables');
0240             if(strcmp( z.class , 'cell'))
0241                 if(z.size(2) > 1 && z.size(1)==1)
0242                     %si es un cell en format columna ya esta be
0243                     obj.variables = variables;
0244                 else
0245                     if(z.size(1) > 1 && z.size(2)==1)
0246                         %si es un cel en format fila cal fer la transposta
0247                         obj.variables = variables';
0248                     else
0249                         %error('DATA/setVariableLabel: El camp variables ha de ser un vector')
0250                         obj.variables = variables;%si hi ha nomes una variable!!
0251                     end
0252                 end
0253             else
0254                 error('DATA/setVariableLabel: variables must be cell type')
0255             end
0256         end
0257         function obj = getVariableLabel(obj, i)
0258             %Retorna els noms de les variables.
0259             %
0260             %Parametres d'entrada:
0261             %
0262             %   i - (opcional) per indicar quines classes bolem
0263             %
0264             %Parametres de sortida:
0265             %
0266             %   obj - es el vector de noms de les variables (format columna)
0267             %
0268             
0269             if nargin > 1 %si indiquen i bolen nomes un subconjunt dels labels
0270                 try
0271                     obj = obj.variables(i);%fem la indexació que demanen
0272                 catch err
0273                     %si hi ha un error en la indexaxió ho indiquem
0274                     error(['DATA\class:' err.message]);
0275                 end
0276             else
0277                 obj = obj.variables;%retornem tots els noms
0278             end
0279             
0280             
0281         end
0282         
0283         %% ->Referencialot
0284         function setBatchLabel(obj, in)
0285             %Fixara els noms dels lots. Aquests son els noms dels diferents
0286             %lots de les nodtres dades, se n'ha d'entra 1 per lot en el
0287             %mateix ordre en que els teim a les dades
0288             %
0289             %Parametres d'entrada:
0290             %
0291             %   variables - És el nou vector de noms dels lots.
0292             %               Aquest vector ha de ser un cellstring
0293             %
0294             %Parametres de sortida:
0295             %
0296             %   Aquest metode no te cap parametre de sortida
0297             %
0298             
0299             %per evitar errors no podrem assignar noms als lots si no
0300             %existeixen lots
0301             if isempty(obj.data)%comprovem si hi ha dades
0302                 error('DATA/setBatchLabel: dades is empty, set dades first.');
0303             end
0304             
0305             %comprovem el format de les dades entrades per l'usuari
0306             z=whos('in');
0307             if(not(strcmp( z.class , 'cell')))%ha de ser un cell
0308                 error('DATA/setBatchLabel: param type is not valid, waiting for cell.');
0309             end
0310             if(size(in,1)~=1) && (size(in,2)~=1)%ha de ser un vector (no una matriu)
0311                 error('DATA/setBatchLabel: class size is not valid, waiting for a vector');
0312             end
0313             
0314             if length(in)~=obj.getBatchCount() %ha de coincidir amb el numero de lots existents
0315                 error('DATA/setBatchLabel: number of batch and classes must be the same');
0316             end
0317             
0318             
0319             %guardem en format fila
0320             if size(in,2)<size(in,1)
0321                 obj.reflot=in';%guardem els noms
0322             else
0323                 obj.reflot=in;%guardem els noms
0324             end
0325         end
0326         function out=getBatchLabel(obj,i)
0327             %retorna el nom dels lots. Aquests son els noms dels diferents
0328             %lots de les nodtres dades. Retornarem tots o nomes els que
0329             %s'ens indiqui.
0330             %
0331             %Parametres d'entrada:
0332             %
0333             %   i - (opcional)es l'index dels lots que volem recuperar-ne
0334             %       el nom, si no s'indica retornarem tots els noms
0335             %
0336             %Parametres de sortida:
0337             %
0338             %   out - És un cell string amb els noms indicats, sempre sera
0339             %         en format fila.
0340             %
0341             
0342             if nargin > 1
0343                 %cas que hi hagi parametre indicant quins noms volem
0344                 try
0345                     out=obj.reflot(i);
0346                 catch err
0347                     error('DATA\getBatchLabel: this index is not valid');
0348                 end
0349             else
0350                 %tornem tot
0351                 out=obj.reflot;
0352             end
0353         end
0354         
0355         %% ->data
0356         %per carregar dades en format 3D
0357         function setRawData(obj,data)
0358             %Carrega la matriu de dades, aquest metode carregra les dades
0359             %directament a l'atribut dades del nostre objecte cal vigilar
0360             %molt be el format que tenen les dades si no pot portar
0361             %problemes.
0362             %Format correcte:
0363             % dim(1)=Temps (Observacions)
0364             % dim(2)=Variables
0365             % dim(3)=Batch
0366             %          _______
0367             %         |______ |
0368             %        |______ ||
0369             %       |______ |||
0370             %   |  |       ||||
0371             % Temps|       |||  /
0372             %   |  |       || Batch
0373             %      |_______|  /
0374             %      - Vars -
0375             %
0376             % **recordar que el matlab les dimensions són 1-ordenades
0377             % 2-absices 3- profunditat**
0378             %
0379             %Parametres d'entrada:
0380             %
0381             %   data - Es una matriu de doubles amb el format descrit
0382             %          anteriorment. Aquesta matriu sera les noves dades de
0383             %          l'objecte actual.
0384             %
0385             %Parametres de sortida:
0386             %
0387             %   *Aquest metode no te parametres de sortida,es un metode
0388             %   que modificara el nostre objecte.
0389             
0390             %Primer de tot comprovem que les dades siguin doubles
0391             z=whos('data');
0392             if(not(strcmp( z.class , 'double')))%dades tipus correcte?
0393                 error('DATA/setRawData: data must be double type')
0394             end
0395             
0396             %nomes ens queda asignar les dades i actualitzar lots.
0397             obj.data=data;%asignem les noves dades
0398             obj.lots=size(data,3);%asignem el nou nombre de lots
0399         end
0400         %per carregar dades en Bach Wide
0401         function setRawDataBW(obj,data,vars,temps,lots)
0402             %Carrega la matriu de dades, ho fara per referencia per
0403             %evitar duplicats. S'espera una matriu desdoblada en Bach wide,
0404             %pertant ha de ser una matriu 2D.i el format esperat és:
0405             % dim(1)=Batch
0406             % dim(2)=Variables*Temps(Observacions)
0407             %
0408             %       _______ _______ _______ _______
0409             %   |  |  V1   |  V2   |  V3   |  V4   |
0410             % Batch|       |       |       |       | ....
0411             %   |  |       |       |       |       |
0412             %      |_______|_______|_______|_______|
0413             %               - Vars - * -Temps -
0414             %
0415             % **recordar que el matlab les dimensions són 1-ordenades
0416             % 2-absices 3- profunditat**
0417             %
0418             %Parametres d'entrada:
0419             %
0420             %   data - Ha de ser una matriu 2D de doubles, son les dades
0421             %           que bolem posar al nostre objecte.
0422             %
0423             %   vars - Es el nombre de variables del proces tambe com a
0424             %           double.
0425             %   temps - Es el nombre de mostres al llarg del temps del
0426             %           nostre proces.
0427             %   lots - numero de lots que ens han entrat
0428             %
0429             %Parametres de sortida:
0430             %
0431             %   *Aquest metode no te parametres de sortida,es un metode
0432             %   que modificara el nostre objecte.
0433             
0434             %primer de tot comprobem el tipus de dades
0435             z=whos('data');
0436             if(strcmp( z.class , 'double'))
0437                 %guardem les dades que ens han passat, les transformem a 3D
0438                 %les guardem a obj.data i actualitzem lots.
0439                 aux=zeros(temps,vars,lots);
0440                 for i=1:lots
0441                     aux(:,:,i)=reshape(data(i,:)',[temps vars]);
0442                 end
0443                 obj.data=aux;
0444                 obj.lots=lots;
0445             else
0446                 error('DATA/setRawDataBW: data must be double type')
0447             end
0448         end
0449         %per carregar dades en Variable Wide
0450         function setRawDataVW(obj,data,vars,temps,lots)
0451             %Carrega la matriu de dades,  ho fara per referencia per evitar
0452             %duplicats. S'espera una matriu 2D en format Variable Wide. Les
0453             %dades les esparem amb el seguent format:
0454             % dim(1)=Batch*Temps(Observacions)
0455             % dim(2)=Variables
0456             %
0457             %       _______
0458             %   |  |       |
0459             %   |  |       |
0460             %   |  |       |
0461             %   |  |_______|
0462             %   |  |       |
0463             %   |  |       |
0464             %   |  |       |
0465             % Bath |_______|
0466             %   *  |       |
0467             % Temps|       |
0468             %   |  |       |
0469             %   |  |_______|
0470             %   |  |       |
0471             %   |  |       |
0472             %   |  |       |
0473             %   |  |_______|
0474             %       -Vars-
0475             %
0476             % **recordar que el matlab les dimensions són 1-ordenades
0477             % 2-absices 3- profunditat**
0478             %
0479             %Parametres d'entrada:
0480             %
0481             %   data - Ha de ser una matriu 2D de doubles, son les dades
0482             %           que bolem posar al nostre objecte.
0483             %
0484             %   vars - Es el nombre de variables del proces tambe com a
0485             %           double.
0486             %   temps - Es el nombre de mostres al llarg del temps del
0487             %           nostre proces.
0488             %   lots - numero de lots que ens han entrat
0489             %
0490             %Parametres de sortida:
0491             %
0492             %   *Aquest metode no te parametres de sortida,es un metode
0493             %   que modificara el nostre objecte.
0494             
0495             %primer de tot comprobem el tipus de dades
0496             z=whos('data');
0497             if(strcmp( z.class , 'double'))
0498                 %guardem les dades que ens han passat, les transformem a 3D
0499                 %les guardem a obj.data i actualitzem lots.
0500                 obj.data=reshape(data',[vars temps lots]);
0501                 permute(obj.data,[2 1 3]);
0502                 obj.lots=lots;
0503             else
0504                 error('DATA/setRawDataVW: data must be double type')
0505             end
0506         end
0507         %Retorna les dades transformades a 2D
0508         function obji = getRawData(obj,metode)
0509             %Retorna les dades transformades a 2D utilitzant bach wide o
0510             %variable wide segons el metode indicat.
0511             %
0512             % Si metode = 0 o 'BW' Les dades es retornaran en format Bach wide
0513             % Si metode = 1 o 'VW' Les dades es retornaran en format Variable wide
0514             %
0515             %Parametres d'entrada:
0516             %
0517             %   metode - pot ser 1 , 0 , 'VW' o 'BW' i ens indica el format de converció
0518             %           a utilitzar
0519             %
0520             %Parametres de sortida:
0521             %
0522             %   obji - aquest metode retorna una matriu de doubles
0523             %         corresponent a l'unfolding de la matriu 3D on
0524             %         s'enmagatzemen les dades internament.
0525             
0526             %per usuaris humans permetem pas de parametres com 'VW' i 'BW'
0527             if ischar(metode)
0528                 if strcmpi(metode,'VW')
0529                     metode = 1;
0530                 end
0531                 if strcmpi(metode,'BW')
0532                     metode = 0;
0533                 end
0534             end
0535             
0536             if(metode~=1 && metode~=0)%ha de ser 1 o 0 si no error
0537                 error('DATA/getRawData: metode must be 1 , 0 , ''VW'' or ''BW''')
0538             end
0539             %nomes cal fer la crida al metode privat que ho fa tot
0540             obji = to2D(obj,metode);
0541         end
0542         %Retorna les dades en 3D
0543         function obji = getRawData3D(obj)
0544             %Aquest metode retorna les dades internes de l'objecte, serà
0545             %una matriu 3D a menys que nomes tinguem un batch. Les dades
0546             %les retornarem com una matriu 3D amb les dades organitzades de
0547             %la seguent manera:
0548             %
0549             % dim(1)=Temps (Observacions)
0550             % dim(2)=Variables
0551             % dim(3)=Batch
0552             %          _______
0553             %         |______ |
0554             %        |______ ||
0555             %       |______ |||
0556             %   |  |       ||||
0557             % Temps|       |||  /
0558             %   |  |       || Batch
0559             %      |_______|  /
0560             %      - Vars -
0561             %
0562             % **recordar que el matlab les dimensions són 1-ordenades
0563             % 2-absices 3- profunditat**
0564             %
0565             %Parametres d'entrada:
0566             %
0567             %   Aquest metode no te parametres d'entrada
0568             %
0569             %Parametres de sortida:
0570             %
0571             %   obji - aquest metode retorna una matriu de doubles
0572             %         corresponent a la matriu 3D on s'enmagatzemen les
0573             %         dades internament.
0574             
0575             obji = obj.data;%retornem la matriu tal com la tenim en memoria
0576         end
0577         
0578         %% ->fases
0579         function setStages(obj,data)
0580             %Funció per entrar les fases del proces.
0581             %
0582             %Parametres d'entrada:
0583             %
0584             %   data - seran les noves fases del proces, ha de ser un
0585             %           vector de cell.
0586             %
0587             %Parametres de sortida:
0588             %
0589             %   Aquest metode no te cap parametre de sortida
0590             %
0591             
0592             %comprovem que el format dels parametres sigui el correcte
0593             z=whos('data');
0594             if(strcmp( z.class , 'cell'))
0595                 obj.fases=data;%actualitzem l'objecte
0596             else
0597                 disp('DATA/setStages: data must be cell type')
0598             end
0599         end
0600         function obji = getStages(obj)
0601             %Retorna les fases del proces.
0602             %
0603             %Parametres d'entrada:
0604             %
0605             %   Aquest metode no te cap parametre d'entrada
0606             %
0607             %Parametres de sortida:
0608             %
0609             %   obji - es un vector de cells, corresponens a les fases
0610             %
0611             
0612             obji=obj.fases;
0613         end
0614         
0615         %% ->durafases
0616         function setStagesDurations(obj,data)
0617             %Funció per fixar la duració de les fases.
0618             %
0619             %Parametres d'entrada:
0620             %
0621             %   data - seran les noves durccions de les fases del proces,
0622             %           han de ser un vector de doubles de la mateixa
0623             %           longitud que el nombre de fases del proces.
0624             %
0625             %Parametres de sortida:
0626             %
0627             %   Aquest metode no te cap parametre de sortida
0628             %
0629             
0630             %Comprobem que el parametre sigui l'esperat
0631             z=whos('data');
0632             if(strcmp( z.class , 'double'))
0633                 if size(data,2)<size(data,1)
0634                     obj.durafases=data';%actualitzem l'objecte
0635                 else
0636                     obj.durafases=data;%actualitzem l'objecte
0637                 end
0638             else
0639                 disp('DATA/setStagesDurations: data must be a vector')
0640             end
0641         end
0642         function obji = getStagesDurations(obj)
0643             %retorna la duracio actual de les fases.
0644             %
0645             %Parametres d'entrada:
0646             %
0647             %   Aquest metode no te cap parametre d'entrada
0648             %
0649             %Parametres de sortida:
0650             %
0651             %   obji - es un vector de doubles, corresponens a les
0652             %          duracions de les fases
0653             %
0654             obji=obj.durafases;
0655         end
0656         
0657         %% ->classes
0658         function setClass(obj,data)
0659             %Funció per fixar les classes de cada batch. Internament les
0660             %classes seran doubles, per l'usuari se li permet entrar cell
0661             %amb text sobre els quals es fara la conversió.
0662             %
0663             %Parametres d'entrada:
0664             %
0665             %   data - seran les noves classes del nostre proces actual,
0666             %           han de ser un vector de doubles de la mateixa
0667             %           longitud que el nombre de fases del proces. O tambe
0668             %           pot ser un vector de cells amb text.
0669             %
0670             %Parametres de sortida:
0671             %
0672             %   Aquest metode no te cap parametre de sortida
0673             %
0674             
0675             if isempty(obj.data)
0676                 error('DATA/setClass:before setting up the class first set the dades');
0677             end
0678             
0679             %Primer comprovem si les dades son correctes
0680             z=whos('data');
0681             if(not(strcmp( z.class , 'double')))
0682                 error('DATA/setClass: invalid type, waiting for double.');
0683             end
0684             if(size(data,1)~=1) && (size(data,2)~=1)
0685                 error('DATA/setClass: invalid class size, waiting for vector');
0686             end
0687             if length(data)~=obj.getBatchCount()
0688                 error('DATA/setClass: batch count number and class count number must be de same');
0689             end
0690             
0691             %posem en format fila
0692             if size(data,2)<size(data,1)
0693                 obj.class=data';%guardem les classes
0694             else
0695                 obj.class=data;%guardem les classes
0696             end
0697         end
0698         function obji = getClass(obj, i)
0699             %retorna la classe de cada batch o del\s batch idexats per i
0700             %
0701             %Parametres d'entrada:
0702             %
0703             %   i - (opcional) per indicar quines classes bolem
0704             %
0705             %Parametres de sortida:
0706             %
0707             %   obji - es un vector de doubles en format fila, corresponens
0708             %          a les classes de cada batch
0709             %
0710             
0711             obji=obj.class;
0712             if nargin > 1
0713                 try
0714                     %si es un string o cellstring hem de recuperar les
0715                     %posicions reals dels lots a que es trfereixen
0716                     z=whos('i');
0717                     if (strcmp( z.class , 'char')  && ~strcmp(i,':'))|| iscellstr(i)
0718                         %recuperem els noms dels lots
0719                         auxnoms = obj.getBatchLabel;
0720                         
0721                         if isempty(auxnoms)
0722                             %si es buit bol dir que aquest objecte no se li han
0723                             %assignat noms de lots -> retornem un error
0724                             error('DATA/getClass: You are indexing using batch names and this object has no batch names!')
0725                         end
0726                         
0727                         if iscellstr(i)
0728                             %si es un cell string cal fer un bucle i anar
0729                             %recuperant les posicions dels lots 1 a 1
0730                             index = [];
0731                             for j=1:length(i)
0732                                 aux = find(strcmp(auxnoms,i{j}));
0733                                 if isempty(aux)
0734                                     %si no existeix el lot que ens demanen mostrem
0735                                     %warning
0736                                     warning('DATA/getClass: You gave an inexistent batch name!')
0737                                 else
0738                                     %ens apuntem el lot que ens demanen
0739                                     index = [index aux];
0740                                 end
0741                             end
0742                             i=index;%posem a i els index dels lots que hem anat trobant
0743                         else
0744                             
0745                             i = find(strcmp(auxnoms,i));
0746                             
0747                             %si no hem trobat el lot mostrem un warning!
0748                             if isempty(i)
0749                                 warning('DATA/getClass: You gave an inexistent batch name!')
0750                             end
0751                         end
0752                     end
0753                     
0754                     obji=obji(i);
0755                 catch err
0756                     error('DATA\getClass:L´index és incorrecte');
0757                 end
0758             end
0759         end
0760         
0761         %% ->Afegir/Treure Casos
0762         %Ajunta 2 objectes dades
0763         function obji = merge(obj,dad)
0764             %Aquesta funció ajuntara 2 objectes dades i retornara un 3r
0765             %objecte format per la unio dels 2, si cridem x.merge(DATA) x
0766             %sera l'objecte principal, d'ell s'agafara el nom, temps,
0767             %duracio de fases... de DATA nomes utilitzarem les dades i les
0768             %classes.
0769             %                                                      _______
0770             % dim(1)=Temps                                        |______ |
0771             % dim(2)=Variables                                   |______ ||
0772             % dim(3)=Batch                                      |______ |||
0773             %         _______              _______             |______ ||||
0774             %        |______ |            |______ |           |______ ||||
0775             %       |______ ||           |______ ||          |______ ||||
0776             %      |______ |||   +      |______ |||     =   |______ ||||  /
0777             %  |  |       ||||      |  |       ||||     |  |       ||||  /
0778             %Temps|       |||  /  Temps|       |||  / Temps|       |||Batch
0779             %  |  |       ||Batch   |  |       ||Batch  |  |       ||  /
0780             %     |_______|  /         |_______|  /        |_______|  /
0781             %     - Vars -             - Vars -             - Vars -
0782             %
0783             % **recordar que el matlab les dimensions són 1-ordenades
0784             % 2-absices 3- profunditat**
0785             %
0786             %Parametres d'entrada:
0787             %
0788             %   dad - Ha de ser un objecte DATA, sera l'objecte secondari
0789             %           el primari es l'actual.
0790             %
0791             %Parametres de sortida:
0792             %
0793             %   obji - Es el nou objecte resultat de ajuntar l'actual amb
0794             %           dad.
0795             %
0796             
0797             %primer de tot comprobem si ens han pasat els parametres correctes
0798             z=whos('dad');
0799             if(strcmp( z.class , 'DATA'))
0800                 %creem el nou objecte
0801                 obji=DATA();
0802                 %agafem les dades de l'actual i les copiem al nou objecte dades
0803                 %que aki anomenem obji.
0804                 obji.nom=obj.nom;
0805                 %Per poder-se unir han de tenir les mateixes variables (Han de
0806                 %ser diferents captures d'un mateix proces)
0807                 obji.variables=obj.variables; %son el mateix proces -> tenen les mateixes variables
0808                 obji.fases=obj.fases;%son el mateix proces -> tenen les mateixes fases
0809                 obji.durafases=obj.durafases;%son el mateix proces -> tenen les mateixes duracions de fase
0810                 %El que fem es ajuntar les 2 matrius de dades, per fer-ho les
0811                 %ajuntem per la dimensió 3(Batch) per tant el nombre de lots
0812                 %caldra actualitzar-lo.
0813 
0814                 %no ens preocupem si hi ha dades repetides, simplement ajuntem les matrius
0815                 obji.data=cat(3,obj.data, dad.data);%dades
0816                 obji.class=[obj.class, dad.class];%unim les classes
0817                 obji.lots=size(obji.data,3);%actualitzem els lots
0818                 
0819                 obji.reflot=[obj.reflot, dad.reflot];
0820 
0821            else
0822                 disp('DATA/merge: dad must be an object of DATA class')
0823             end
0824         end
0825         %Afegir 1 o varis lots
0826         function addBatch(obj,dad, clase,ref)
0827             %Aquesta funció afegeix un o diversos Batch a les nostres
0828             %dades. Les mides del lot han de ser concordants amb les de la
0829             %resta de l'estructura que tenim.
0830             %                                                      _______
0831             % dim(1)=Temps                                        |______ |
0832             % dim(2)=Variables                                   |______ ||
0833             % dim(3)=Batch                                      |______ |||
0834             %         _______              _______             |______ ||||
0835             %        |______ |            |______ |           |______ ||||
0836             %       |______ ||           |______ ||          |______ ||||
0837             %      |______ |||   +      |______ |||     =   |______ ||||  /
0838             %  |  |       ||||      |  |       ||||     |  |       ||||  /
0839             %Temps|       |||  /  Temps|       |||    Temps|       |||Batch
0840             %  |  |       ||Batch   |  |       ||       |  |       ||  /
0841             %     |_______|  /         |_______|           |_______|  /
0842             %     - Vars -             - Vars -             - Vars -
0843             %
0844             %      Actual                 dad                 Resultat
0845             % **recordar que el matlab les dimensions són 1-ordenades
0846             % 2-absices 3- profunditat**
0847             %
0848             %Parametres d'entrada:
0849             %
0850             %    dad - matriu de doubles 2D o 3D
0851             %
0852             %    clase -  es un vector de doubles
0853             %
0854             %    ref - (opcional) es la referencia o nom del lot
0855             %
0856             %Parametres de sortida:
0857             %
0858             %   No en te
0859             %
0860 
0861             %mirem si les dades son correctes
0862             z=whos('dad');
0863             if(not(strcmp( z.class , 'double')))
0864                 error('DATA/afegeix:dad has an invalid class, waiting double.');
0865             end
0866             % les mides son correctes?
0867             if ~isempty(obj.data)
0868             if(not(z.size(1)==size(obj.data,1) && z.size(2)==size(obj.data,2)))%ha de ser un vector columna
0869                 error('DATA/afegeix: dad batch size is not the same than actual batch size')% format incorrecte
0870             end 
0871             end
0872             
0873             %comprovem que la classe del segon operant sigui correcte
0874             z=whos('clase');
0875             if(not(strcmp( z.class , 'double')))
0876                 error('DATA/afegeix: class type not valid, waiting for double.');
0877             end
0878             
0879             if(z.size(1)==1 && z.size(2)>=1)%vector fila
0880                 obj.class=[obj.class, clase];%afegim el nou element/s a derrera
0881             elseif(z.size(1)>=1 && z.size(2)==1)%vector columna
0882                 obj.class=[obj.class, clase'];%afegim el nou element/s a derrera fent transpost internament tenim un vector fila
0883             else
0884                 error('DATA/afegeix:classe size is not valid, waiting for vector.');
0885             end
0886             %afegim el lot a les dades
0887             obj.data=cat(3,obj.data, dad);%els afegim darrere per la 3a dimenció
0888             obj.lots=size(obj.data,3);%actualitzem el numero de lots
0889             if nargin == 4
0890                obj.reflot=[obj.reflot ref];
0891             end
0892         end
0893         %treure 1 o varis lot
0894         function deleteBatch(obj,i)
0895             %Treu els lots indexats per ''i". ''i" pot ser un double, o un
0896             %logical en format vector de 1 a n elements on n es el numero
0897             %de lots. O qualsebol format valid en indexacions al Matlab.
0898             %
0899             %
0900             % dim(1)=Temps
0901             % dim(2)=Variables
0902             % dim(3)=Batch
0903             %         _______
0904             %        |______ |                      _______
0905             %       |______ ||                     |______ |
0906             %      |______ |||                    |______ ||
0907             %  |  |       ||||     - [1] =    |  |       |||
0908             %Temps|       |||  /            Temps|       |||
0909             %  |  |       ||Batch             |  |       ||
0910             %     |_______|  /                   |_______|
0911             %     - Vars -                        - Vars -
0912             %
0913             %      Actual          index          Resultat
0914             % **recordar que el matlab les dimensions són 1-ordenades
0915             % 2-absices 3- profunditat**
0916             %
0917             %Parametres d'entrada:
0918             %
0919             %    i - els lots que es bol treure
0920             %
0921             %Parametres de sortida:
0922             %
0923             %   No en te
0924             %
0925             
0926             %Comprovem que el tipus de dades sigui el correcte
0927             z=whos('i');
0928             % es double ?
0929             if(not(strcmp( z.class , 'double')) && not(strcmp( z.class , 'logical')) && not(strcmp( z.class , 'char')) && ~iscellstr(i))
0930                 error('DATA/treu: waiting for double or logical')
0931             end
0932             % es vector columna o 1*1?
0933             if(length(z.size())>2 && (z.size(1)==1 || z.size(2)==1))%ha de ser un vector
0934                 error('DATA/treu: waiting for vector')% format incorrecte
0935             end
0936             
0937             %si es un string o cellstring hem de recuperar les posicions reals dels lots a que es trfereixen
0938             if (strcmp( z.class , 'char')  && ~strcmp(i,':'))|| iscellstr(i)  
0939                 %recuperem els noms dels lots
0940                 auxnoms = obj.getBatchLabel;
0941                 
0942                 if isempty(auxnoms)
0943                     %si es buit bol dir que aquest objecte no se li han
0944                     %assignat noms de lots -> retornem un error
0945                     error('DATA/treu: You are indexing using batch names and this object has no batch names!')
0946                 end
0947                 
0948                 if iscellstr(i)
0949                     %si es un cell string cal fer un bucle i anar
0950                     %recuperant les posicions dels lots 1 a 1
0951                     index = [];
0952                     for j=1:length(i)
0953                         aux = find(strcmp(auxnoms,i{j}));
0954                         if isempty(aux)
0955                             %si no existeix el lot que ens demanen mostrem
0956                             %warning
0957                             warning('DATA/treu: You gave an inexistent batch name!')
0958                         else
0959                             %ens apuntem el lot que ens demanen
0960                             index = [index aux];
0961                         end
0962                     end
0963                     i=index;%posem a i els index dels lots que hem anat trobant
0964                 else
0965                     
0966                     i = find(strcmp(auxnoms,i));
0967                     
0968                     %si no hem trobat el lot mostrem un warning!
0969                     if isempty(i)
0970                         warning('DATA/treu: You gave an inexistent batch name!')
0971                     end
0972                 end
0973             end
0974             
0975             %format correcte
0976             
0977             x=logical(1:obj.lots);%x es un vector de 1 logics de longitud = al numero de lots
0978             x(i)=0;%posem a 0 els que bolen eliminar
0979             if(length(x)<=obj.lots)%comprovem el tamany del vector que ens han passat / o la posicio que volien eliminar
0980                 obj.data=obj.data(:,:,x);%treiem els que cal de les dades
0981                 obj.class=obj.class(x);%treiem els que cal de les classes
0982                 if not(isempty(obj.reflot))
0983                     obj.reflot=obj.reflot(x);
0984                 end
0985                 obj.lots=size(obj.data,3);%Actualitzem els lots
0986             else
0987                 error('DATA/treu: batch index out of bounds')
0988             end
0989         end
0990         %retorna el lot/lots indicats
0991         function [data clas noms]=getBatch(obj, i)
0992             %retorna el lot o lots indicats per el parametre d'entrada 'i',
0993             %aquest por ser qualsebol tipus d'indexació valida en matlab.
0994             %
0995             %              _______
0996             %             |______ |
0997             %            |______ ||
0998             %           |______ |||
0999             %          |______ |||| - 8
1000             %         |______ |||| - 7
1001             %        |______ |||| - 6
1002             %       |______ |||| - 5   /
1003             %   |  |       |||| - 4   /
1004             % Temps|       ||| - 3 Batch
1005             %   |  |       || - 2   /
1006             %      |_______| - 1   /
1007             %      - Vars -
1008             %
1009             %
1010             %Parametres d'entrada:
1011             %
1012             %    i - index del lot/s que es vol recuperar
1013             %
1014             %Parametres de sortida:
1015             %
1016             %    data - matriu de doubles 2D son les dades del lot
1017             %
1018             %    clas -  es un double i correspon a la classe del lot
1019             %
1020             %    noms - es el nom del batch
1021             %
1022             
1023             %Comprovem que el tipus de dades sigui el correcte
1024             z=whos('i');
1025             % es double ?
1026             if(not(strcmp( z.class , 'double')) && not(strcmp( z.class , 'logical')) && not(strcmp( z.class , 'char')) && ~iscellstr(i))
1027                 error('DATA/treu: Waiting for double, logical, lot identificator(char)')
1028             end
1029             % es vector columna o 1*1?
1030             if(length(z.size())>2 && (z.size(1)==1 || z.size(2)==1))%ha de ser un vector
1031                 error('DATA/treu: Waiting for vector')% format incorrecte
1032             end
1033             
1034             %si es un string o cellstring hem de recuperar les posicions reals dels lots a que es trfereixen
1035             if (strcmp( z.class , 'char')  && ~strcmp(i,':'))|| iscellstr(i)  
1036                 %recuperem els noms dels lots
1037                 auxnoms = obj.getBatchLabel;
1038                 
1039                 if isempty(auxnoms)
1040                     %si es buit bol dir que aquest objecte no se li han
1041                     %assignat noms de lots -> retornem un error
1042                     error('DATA/treu: You are indexing using batch names and this object has no batch names!')
1043                 end
1044                 
1045                 if iscellstr(i)
1046                     %si es un cell string cal fer un bucle i anar
1047                     %recuperant les posicions dels lots 1 a 1
1048                     index = [];
1049                     for j=1:length(i)
1050                         aux = find(strcmp(auxnoms,i{j}));
1051                         if isempty(aux)
1052                             %si no existeix el lot que ens demanen mostrem
1053                             %warning
1054                             warning('DATA/treu: You gave an inexistent batch name!')
1055                         else
1056                             %ens apuntem el lot que ens demanen
1057                             index = [index aux];
1058                         end
1059                     end
1060                     i=index;%posem a i els index dels lots que hem anat trobant
1061                 else
1062                     
1063                     i = find(strcmp(auxnoms,i));
1064                     
1065                     %si no hem trobat el lot mostrem un warning!
1066                     if isempty(i)
1067                         warning('DATA/treu: You gave an inexistent batch name!')
1068                     end
1069                 end
1070             end
1071             
1072             %Recuperem els lots que ens demanen!
1073             data=obj.data(:,:,i);
1074             
1075             %les classes
1076             if isempty(obj.class)
1077                 clas =[];
1078             else
1079                 clas=obj.class(i);
1080             end
1081             
1082             
1083             %i les referencies
1084             if isempty(obj.reflot)
1085                 noms={};
1086             else
1087                 noms=obj.reflot(i);
1088             end
1089             
1090         end
1091         
1092         %% -> Barrejar els lots
1093         function index=shuffle(obj,index)
1094             %Funció per barrejar els lots de la base de casos aleatoriament
1095             %o be amb els indexs que ens passa l'usuari
1096             %
1097             %Parametres d'entrada:
1098             %
1099             %    index - vector que indica per cada lot la nova posició
1100             %            desitjada si no existeix s'assigna aleatoriament
1101             %
1102             %Parametres de sortida:
1103             %
1104             %    index - vector de doubles qu indica la posició antiga dels lots
1105             %
1106             
1107            
1108             if nargin < 2%comprovem si ens passen index
1109                  %creem l'index
1110                 index=randperm(obj.getBatchCount());
1111             else
1112                 %controlem que l'index que ens passen sigui correcte
1113                 if(size(index)~=obj.getBatchCount())%coincideix mida
1114                     error('DATA\shuffle: Invalid Index');
1115                 end
1116                 if sum(sort(index) == 1:obj.getBatchCount())~=obj.getBatchCount() %hi son tots
1117                     error('DATA\shuffle:Invalid Index');
1118                 end
1119             end
1120             
1121             %fem la ordenació corresponent amb l'index
1122             obj.data=obj.data(:,:,index);%a les dades
1123             
1124             %a les classes
1125             if isempty(obj.class)%comprovem si la classe existeix
1126                 warning('DATA\shuffle:class is empty');
1127             else
1128                 obj.class=obj.class(index);
1129             end
1130             
1131             %i a les referencies
1132             if isempty(obj.reflot)
1133                 warning('DATA\shuffle:lot reference is empty');
1134             else
1135                 obj.reflot=obj.reflot(index);
1136             end
1137         end
1138 
1139         %% -> guardar/carregar dades
1140         function save(obj,fitxer,format)
1141             %Métode que llegeix un fitxer per inicialitzar un objecte DATA.
1142             %El paràmetre fitxer inclou el nom i extensio del fitxer (i si
1143             %cal , la ruta del directori on es troba la informacio). Per
1144             %una altra banda el parametre format" indica el format del
1145             %fitxer que s'ha de llegir. Els formats valids son:
1146             %
1147             %
1148             %"mat": guardar la informacio en format per defecte de Matlab,
1149             %aquest format obliga a usar la extensio de fitxer ".mat".
1150             %
1151             %"csv": guardar la informacio en un fitxer on els valors se
1152             %separen per comes De format propi.
1153             %
1154             %Parametres d'entrada:
1155             %
1156             %   fitxer - String amb el nom (i ruta del directori,si cal)
1157             %            amb la informacio a llegir.
1158             %
1159             %   format - Format del fitxer a llegir. Els formats valids
1160             %            son: \mat" i \csv".
1161             %
1162             
1163             switch upper(format)
1164                 case 'MAT'
1165                     %cridem el save de matlab
1166                     save(fitxer,'obj');
1167                 case 'CSV'
1168                     %creem el fitxer amb el format propi
1169                     fid=fopen(fitxer, 'w+');
1170                     fclose(fid);
1171                     aux=[{'Nom'} {obj.nom}];%sempre sera un string no hi ha problema
1172                     cell2csv(fitxer,aux,',');
1173                     fid=fopen(fitxer, 'a+');
1174                     fprintf(fid, '\r\n');
1175                     fclose(fid);
1176                     aux=[{'Variables'} {length(obj.variables)} ];% sempre seran strings nomes necesitem saver quantes seran
1177                     cell2csv(fitxer,aux,',');
1178                     fid=fopen(fitxer, 'a+');
1179                     fprintf(fid, '\r\n');
1180                     fclose(fid);
1181                     cell2csv(fitxer,obj.variables,',');
1182                     fid=fopen(fitxer, 'a+');
1183                     fprintf(fid, '\r\n');
1184                     fclose(fid);
1185                     aux=[{'Fases'} {length(obj.fases)} ];% sempre seran numeros nomes necesitem saver quantes seran
1186                     cell2csv(fitxer,aux,',');
1187                     fid=fopen(fitxer, 'a+');
1188                     fprintf(fid, '\r\n');
1189                     fclose(fid);
1190                     cell2csv(fitxer,obj.fases',',');
1191                     
1192                     fid=fopen(fitxer, 'a+');
1193                     fprintf(fid, '\r\n');
1194                     fclose(fid);
1195                     aux=[{'Duracio de Fases'} {length(obj.durafases)}];% sempre seran numeros nomes necesitem saver quantes seran
1196                     cell2csv(fitxer,aux,',');
1197                     fid=fopen(fitxer, 'a+');
1198                     fprintf(fid, '\r\n');
1199                     fclose(fid);
1200                     aux=[];
1201                     for i = 1:length(obj.durafases)
1202                         aux= [aux {obj.durafases(i)}];
1203                     end
1204                     cell2csv(fitxer,aux,',');
1205                     fid=fopen(fitxer, 'a+');
1206                     fprintf(fid, '\r\n');
1207                     fclose(fid);
1208                     aux=[{'ref. Lots'} {length(obj.reflot)} ];
1209                     cell2csv(fitxer,aux,',');
1210                     fid=fopen(fitxer, 'a+');
1211                     fprintf(fid, '\r\n');
1212                     fclose(fid);
1213                     
1214                     cell2csv(fitxer,obj.reflot,',');
1215                     fid=fopen(fitxer, 'a+');
1216                     fprintf(fid, '\r\n');
1217                     fclose(fid);
1218                     aux=[ {'class'} {length(obj.class)}];% sempre seran numeros nomes necesitem saver quantes seran
1219                     cell2csv(fitxer,aux,',');
1220                     fid=fopen(fitxer, 'a+');
1221                     fprintf(fid, '\r\n');
1222                     fclose(fid);
1223                     aux=[];
1224                     for i = 1:length(obj.class)
1225                         aux= [aux {obj.class(i)}];
1226                     end
1227                     cell2csv(fitxer,aux,',');
1228                     fid=fopen(fitxer, 'a+');
1229                     fprintf(fid, '\r\n');
1230                     fclose(fid);
1231                     aux=[{'data'} {size(obj.data,1)} {size(obj.data,2)} {size(obj.data,3)}];% sempre seran numeros
1232                     cell2csv(fitxer,aux,',');
1233                     fid=fopen(fitxer, 'a+');
1234                     fprintf(fid, '\r\n');
1235                     fclose(fid);
1236                     dlmwrite(fitxer,obj.getRawData(1),'-append','newline','pc','delimiter',',')  % 0=BW 1=VW
1237             end
1238         end
1239         function load(obj,fitxer,format)
1240             %Metode que llegeix un fitxer per inicialitzar un objecte DATA.
1241             %El parametre fitxer" inclou el nom i extensio del fitxer(i si
1242             %cal , la ruta del directori on es troba la informacio). Per una
1243             %altra banda el parametre "format" indica el format del fitxer
1244             %que s'ha de llegir. Els formats valids son:
1245             %
1246             %
1247             %"mat": guardar la informacio en format per defecte de Matlab,
1248             %aquest format obliga a usar la extensio de fitxer ".mat".
1249             %
1250             %"csv": guardar la informacio en un fitxer on els valors se
1251             %separen per comes De format propi.
1252             %
1253             %Parametres d'entrada:
1254             %
1255             %   fitxer - String amb el nom (i ruta del directori,si cal)
1256             %            amb la informacio a llegir.
1257             %
1258             %   format - Format del fitxer a llegir. Els formats valids
1259             %            son: \mat" i \csv".
1260             %
1261             
1262             switch upper(format)
1263                 case 'CSV'
1264                     fid=fopen(fitxer, 'r');
1265                     if fid <= 0
1266                         error('DATA\Load: error while opening file');
1267                     end
1268                     
1269                     %nom
1270                     s=fgetl(fid);
1271                     a=textscan(s,'%s','delimiter',',');
1272                     if not(strcmpi(a{1}(1),'NOM'))
1273                         error('DATA\Load: NOM marker is not there');
1274                     end
1275                     
1276                     if length(a{1})>1
1277                         obj.setName(a{1}{2});
1278                     else
1279                         obj.nom=[];
1280                     end
1281                     
1282                     
1283                     %variables
1284                     s=fgetl(fid);
1285                     a=textscan(s,'%s','delimiter',',');
1286                     if not(strcmpi(a{1}(1),'VARIABLES'))
1287                         error('DATA\Load: VARIABLES marker is not there');
1288                     end
1289                     
1290                     if length(a{1})>1
1291                         num=str2double(a{1}(2));
1292                     else
1293                         error('DATA\Load: after VARIABLES marker you must give a number');
1294                     end
1295                     
1296                     s=fgetl(fid);
1297                     if num >0
1298                         a=textscan(s,'%s','delimiter',',');
1299                         if length(a{1})~= num
1300                             error('DATA\Load: VARIABLES given number and found number must match');
1301                         end
1302                         obj.setVariableLabel(a{1});
1303                     else
1304                         obj.variables=[];
1305                     end
1306                     
1307                     
1308                     %fases
1309                     s=fgetl(fid);
1310                     a=textscan(s,'%s','delimiter',',');
1311                     if not(strcmpi(a{1}(1),'FASES'))
1312                         error('DATA\Load: FASES marker not found');
1313                     end
1314                     
1315                     if length(a{1})>1
1316                         num=str2double(a{1}(2));
1317                     else
1318                         error('DATA\Load: after FASES marker you must give a number');
1319                     end
1320                     
1321                     s=fgetl(fid);
1322                     if num >0
1323                         a=textscan(s,'%s','delimiter',',');
1324                         if length(a{1})~= num
1325                             error('DATA\Load: FASES given number and found number must match');
1326                         end
1327                         obj.setStages(a{1});
1328                     else
1329                         obj.fases=[];
1330                     end
1331                     
1332                     
1333                     %Duracio de fases
1334                     s=fgetl(fid);
1335                     a=textscan(s,'%s','delimiter',',');
1336                     if not(strcmpi(a{1}(1),'Duracio de fases'))
1337                         error('DATA\Load: Duracio de fases marker not found');
1338                     end
1339                     
1340                     if length(a{1})>1
1341                         num=str2double(a{1}(2));
1342                     else
1343                         error('DATA\Load:after Duracio de fases marker you must give a number');
1344                     end
1345                     
1346                     s=fgetl(fid);
1347                     if num >0
1348                         a=textscan(s,'%s','delimiter',',');
1349                         if length(a{1})~= num
1350                             error('DATA\Load: Duracio de fases given number and found number must match');
1351                         end
1352                         obj.setStagesDurations(str2double(a{1}));
1353                     else
1354                         obj.durafases=[];
1355                     end
1356                     
1357                     
1358                     % ref. lots
1359                     s=fgetl(fid);
1360                     a=textscan(s,'%s','delimiter',',');
1361                     if not(strcmpi(a{1}(1),'ref. lots'))
1362                         error('DATA\Load:ref. batch marker not found');
1363                     end
1364                     
1365                     if length(a{1})>1
1366                         num=str2double(a{1}(2));
1367                     else
1368                         error('DATA\Load:after ref. batch marker you must give a number');
1369                     end
1370                     
1371                     s=fgetl(fid);
1372                     if num >0
1373                         a=textscan(s,'%s','delimiter',',');
1374                         if length(a{1})~= num
1375                             error('DATA\Load: ref. batch given number and found number must match');
1376                         end
1377                         nomlots=a{1};%Setnomlot s'ha de fer despres d'entrar les dades!! nomes ens guardem el valors de moment
1378                     else
1379                         obj.reflot=[];
1380                         nomlots=-1;
1381                     end
1382                     
1383                     %classes
1384                     s=fgetl(fid);
1385                     a=textscan(s,'%s','delimiter',',');
1386                     if not(strcmpi(a{1}(1),'class'))
1387                         error('DATA\Load:class marker not found');
1388                     end
1389                     
1390                     if length(a{1})>1
1391                         num=str2double(a{1}(2));
1392                     else
1393                         error('DATA\Load:after duracions de fases marker you must give a number');
1394                     end
1395                     
1396                     s=fgetl(fid);
1397                     if num >0
1398                         a=textscan(s,'%s','delimiter',',');
1399                         if length(a{1})~= num
1400                             error('DATA\Load: duracions de fases given number and found number must match');
1401                         end
1402                         classes=str2double(a{1});
1403                     else
1404                         obj.durafases=[];
1405                         classes=-1;
1406                     end
1407                     
1408                     %DATA
1409                     s=fgetl(fid);
1410                     a=textscan(s,'%s','delimiter',',');
1411                     if not(strcmpi(a{1}(1),'data'))
1412                         error('DATA\Load:data marker not found');
1413                     end
1414                     
1415                     if length(a{1})==4
1416                         tmps=str2double(a{1}(2));
1417                         var=str2double(a{1}(3));
1418                         lot=str2double(a{1}(4));
1419                     else
1420                         error('DATA\Load:data marker format is data,time,variables number,batch number,');
1421                     end
1422                     
1423                     if(tmps == 0 && var==0)
1424                         obj.data=[];
1425                     else
1426                         M=dlmread(fitxer,',',12,0);
1427                         Z=reshape(M',var,tmps,lot);
1428                         obj.data=permute(Z,[2 1 3]);
1429                         obj.lots=size(obj.data,3);
1430                         
1431                         if iscell(nomlots)
1432                             obj.setBatchLabel(nomlots);
1433                         end
1434                         if classes ~= -1
1435                             obj.setClass(classes);
1436                         end
1437                     end
1438                     case 'MAT'
1439                         %cridem el load de matlab
1440                          load(fitxer);
1441             end
1442         end
1443         
1444 %-------------------------------------------------------------------------%
1445 %% -------------------- Visualització de l'objecte -----------------------
1446 %-------------------------------------------------------------------------%
1447         %sobreescriptura event de dobleclick sobre un objecte DATA
1448         function openvar(nom,~)
1449             %Aquesta es una funció que sobreescriu l'event per defecte de
1450             %doble click sobre un objecte de tipus DATA en el workspace.
1451             %sobreescrivim la funció de visualització per defecte,
1452             %el parametre ignorat és l'objecte actual el nom ens el passen
1453             %en format text. Aqui invocarem una pantalla especifica per
1454             %visualitzar l'objecte.
1455             %
1456             %!!ATENCIO!! -> Aquest metode no hauria de ser invocat per
1457             %l'usuari directament a menys que sapiga molt bé que esta fent!
1458             
1459             x=whos('nom');
1460             if strcmp(x.class,'DATA')
1461                 %no puc saber el nom de la variable -> no fem res!
1462             else
1463                 if(evalin('base',['size(' nom ');']) == [1 1])
1464                     Menu_Editar_Dades2(nom)
1465                 else
1466                     %arrays, no podem obrir-los amb la UI!!
1467                 end
1468             end
1469         end
1470         %visualització de l'objecte per consola i menus desplegables de Matlab
1471         function disp(obj,~)
1472             %funció que sobreescriu la visualització de l'objecte per
1473             %consola i en alguns menus desplegables de matlab.
1474             %Mostrarem informació util per l'usuari (tamany de les dades)
1475             %en comptes de la informació per defecte.
1476             %
1477             % Aquesta funció s'invoca automaticament per Matlab quan cal
1478             % l'usuari no necesita invocarla en cap moment.
1479             
1480             %sobre escric la visualització de l'objecte
1481             if nargin ~=2
1482                 disp(['nom = ' obj.nom])
1483             end
1484             disp(['Num_temps = ' num2str(obj.getSampleCount())])
1485             disp(['Num_vars = ' num2str(obj.getVariableCount())])
1486             disp(['Num_batch = ' num2str(obj.getBatchCount())])
1487         end
1488     end
1489     
1490 %-------------------------------------------------------------------------%
1491 %% --------------------------- Privades -----------------------------------
1492 %-------------------------------------------------------------------------%
1493     
1494     methods(Access = private)
1495         %converteix la matriu a 2D
1496         function x = to2D(obj,metode)
1497             %Metode privat de la classe DATA que converteix la matriu de
1498             %dades interna a 2D, si metode es 1 fara un unfolding per
1499             %variable wide si es 0 el fara per bach wide.
1500             %
1501             %Parametres d'entrada:
1502             %
1503             %   metode - pot ser 1 o 0, 1= VW i 0= BW
1504             %
1505             %Parametres de sortida:
1506             %
1507             %   x -  son les dades resultants de l'unfolding.
1508             %
1509             
1510             %recuperem el tamany de les dades
1511             z=size(obj.data);
1512             d=length(z);
1513             if(d==3)
1514                 %dades de 3D
1515                 if(metode == 0)
1516                     %metode escollit es BW
1517                     x=reshape(obj.data,z(2)*z(1),z(3))';
1518                 else
1519                     %metode escollit es VW
1520                     c=permute(obj.data,[1 3 2]);
1521                     x=reshape(c, z(1)*z(3),z(2));
1522                 end
1523             else
1524                 if(d==2)
1525                     %dades son 2D -> nomes tenim 1 lot
1526                     x=obj.data;
1527                     if (metode == 0) %si s'ha de forçar conversió i BW
1528                         
1529                         x=reshape(obj.data,z(2)*z(1),1)';
1530                     end
1531                 else
1532                     disp('DATA/to2D: Matrix shape error');
1533                     x=[];
1534                 end
1535             end
1536         end
1537     end
1538 end

Generated on Wed 12-Sep-2012 13:03:54 by m2html © 2005