Home > Codi > PCA.m

PCA

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) PCA < handle
0002     %La classe PCA sera l'encarregada de mantenir en memoria les dades
0003     %necessaries per fer els calculs sobre un model PCA. Aquesta classe
0004     %tambe permet la projecció de dades sobre el model PCA emmagatzemat,
0005     %creant aixi els PCA no models.
0006     %
0007     %Les atributs d'aquest objecte són ptivats i són:
0008     %
0009     %    DATA - Objecte tipus DATA on hi ha el conjunt de dades inicials
0010     %           utilitzades per crear el model PCA. Aquest camp
0011     %           s'inicialitza amb el constructor de la clase i es va
0012     %           actualitzant segons les operacions fetes.
0013     %           Aquest atribut pot ser recuperat en tot moment amb getDATA.
0014     %
0015     %
0016     %    estandar - Es l'atribut intern o indiquem si el proces esta
0017     %               estandaritzat o no ho esta. Aquest atribut no és
0018     %               accesible des de l'exterior de la classe per cap
0019     %               matode.
0020     %
0021     %    model - aquesta variable ens indica si les dades emmagatzemades a
0022     %            l'objecte formen un model o provenen d'una projecció soble
0023     %            un model extern. Podem consultar-ho amb el metode ismodel.
0024     %
0025     %    Z - Matriu bidimencional de doubles, on s'hi emmagatzemaran les
0026     %        dades Estandaritzades i s'inicialitzarŕ a null.
0027     %
0028     %    P - Matriu bidimencional de doubles, on guardem la matriu de
0029     %        Components principals, El seu valor per defecte és null.
0030     %
0031     %    Num - Es el numero de components principals que s'utilitzaran per
0032     %          fer el model.Es pot consultar amb getNum.
0033     %
0034     %    Num_save - Numero de components principals que s'utilitzaran per
0035     %               si s'entra manualment i poder evitar que es demani
0036     %               diversos cops a l'usuari.
0037     %
0038     %    T - Matriu de doubles on guardem la projecció de Z sobre el model
0039     %        PCA. Ha de tenir tantes files com Z i tantes columnes com P.
0040     %        El seu valor per defecte és null.
0041     %
0042     %    Landa - Vector que conté els valors propis associats a les
0043     %            components principals retingudes. Ha de tenir tants
0044     %            elements com columnes té P. El seu valor per defecte és
0045     %            null.
0046     %
0047     %    Landai - Vector que conté els valors propis associats a totes les
0048     %             components principals. Té el nombre d’elements igual al
0049     %             rang de Z.
0050     %
0051     %    sta - Vector de doubles que conte la desviació de cadascuna de les
0052     %          variables mesurades del procés. Té tants elements com
0053     %          columnes té Z.
0054     %
0055     %    mea - Vector de doubles que conte la mitjana de cadascuna de les
0056     %          variables mesurades del procés. Té tants elements com
0057     %          columnes té Z.
0058     %
0059     %    E - Matriu de doubles que conté la matriu residual de projectar Z
0060     %        sobre el model PCA.
0061     %
0062     %    T2 - Vector de doubles que conte els valors de l’índex T^2 de cada
0063     %         observació en Z. Te tants elements com files té Z.
0064     %
0065     %    LimT2 - Double que indica el límit de T^2. qualsevol observació
0066     %            amb un valor de T^2 per sobre d’aquest límit es considera
0067     %            defectuosa per culpa de T^2.
0068     %
0069     %    LimQ - Double que indica el límit de Q. qualsevol observació amb
0070     %           un valor de Q per sobre d’aquest límit es considera
0071     %           defectuosa per culpa de Q.
0072     %
0073     %    metode -Double que identifica el mčtode de selecció del nombre de
0074     %            components principals que s’utilitzarŕ. Els possibles
0075     %            valors són:
0076     %             0=Manual
0077     %             1=kaiser
0078     %             2=colze
0079     %             3=colze+punt recomenat
0080     %             4=% de variŕncia explicada
0081     %             5=VRE
0082     %
0083     %    metodee - Mčtode d’estandardització que s’utilitzarŕ.
0084     %              Els valors vŕlids són:
0085     %              1=AS - Auto scaling (opció per defecte)
0086     %              2=GS - Grup scaling
0087     %              3=CS - Continous scaling
0088     %              4=BS - Block scaling
0089     %
0090     %    treuFM - Booleŕ que indica si volem treure la forma mitja de les
0091     %             dades (treuFM = true, valor per defecte), o no (treuFM =
0092     %             false). El fet de treure la forma mitja afecta si estem
0093     %             treballant en VW o en BW i s’aplica el Continuous
0094     %             scaling.
0095     %
0096     %    conv - Booleŕ que fixa el mčtode de desdoblar la matriu
0097     %           tridimensional de dades. conv = false desdobla en BW (opció
0098     %           per defecte), mentre que conv = 1 desdobla en VW.
0099     %           0= BW
0100     %           1= VW
0101     %
0102     %    structura - Estructura de dades on es guarda tota la informació
0103     %                relacionada amb el mčtode del VRE.
0104     %
0105     %    analitic - Boolea que indica el metode que es vol fer servir en
0106     %               calcular els limits de les contribucións ( 0=3_sigma i
0107     %               1=analitic)
0108     %
0109     %    ContMetode - Boolea que indica el metode que es vol fer servir en
0110     %                 calcular les contribucións (0 = descartar negatius i
0111     %                 1 = negatius i positius)
0112     %
0113     %    CLimQstd - limit de Q - Desviació tipica - Vector de doubles que
0114     %              conté la desviació estŕndard de les contribucions de Q.
0115     %              S’utilitza per al cŕlcul del límit d’aquestes
0116     %              contribucions.
0117     %
0118     %    CLimQmea - limit de Q - Mitjana - Vector de doubles per
0119     %               emmagatzemar la mitjana de les contribucions de Q.
0120     %               S’utilitza per al cŕlcul del límit d’aquestes
0121     %               contribucions.
0122     %
0123     %    CLimT2std - limit de T2 - Desviació tipica - Vector de doubles que
0124     %                conté la desviació estŕndard de les contribucions de T
0125     %                . s’utilitza per al cŕlcul del límit d’aquestes
0126     %                contribucions.
0127     %
0128     %    CLimT2mea - limit de T2 - Mitjana - Vector de doubles que conté la
0129     %                mitjana de les contribucions de T . S’utilitza per al
0130     %                cŕlcul del límit d’aquestes contribucions.
0131     %
0132 %-------------------------------------------------------------------------%
0133 %% -----------------------------VARIABLES---------------------------------
0134 %-------------------------------------------------------------------------%
0135     
0136     properties (Access = private) %(Access = public) %Els atributs de la classe son privats, per fer proves o debugar canviar a (Access = public)
0137         % Propietats privades del nostre objecte, aqui nomes les definirem,
0138         % tot i aixo sels podria asignar un valor per defecte. En el nostre
0139         % cas el valor per defecte l'assignarem al constructor.
0140         DATA;%Obgecte tipus DATA on hi haura les nostres dades inicials
0141         estandar;%vadiable que ens indica si el proces esta estandaritzat o no
0142         model;% ens indica si les dades emmagatzemades a la c
0143         
0144         Z;%dades estandaritzades
0145         P;%Components principals
0146         Num;%numero de components principals que s'utilitzaran per fer el model
0147         Num_save;%numero de components principals que s'utilitzaran per fer el model (si s'entra manualment el guardem aqui)
0148         T;%matriu de T
0149         Landa;%matriu de landas
0150         Landai;%les landas inicials
0151         sta;%desviació estandard
0152         mea;%mitjana
0153         E;%Error
0154         T2;%T^2
0155         LimT2;%Limit de T^2
0156         LimQ;%Limit de Q
0157         metode;%el metode de seleccio de numero de components que s'utilitzara  0=Manual 1=kaiser 2=colze 3=colze+punt recomenat 4=% de landa explic
0158         metodee;%es el metode d'estandarització que s'utilitzara 1=autoscaling 2=GS 3=CS 4=BS 5=CBR
0159         treuFM;%Treure la forma mitja 1=si 0 = no nomes afecta si estem trevallan en VW
0160         conv;%0= BW 1 = VW
0161         analitic;%0=3_sigma; 1=analitic
0162         structura;%estructura de dades on guardarem tot lo necesari per el CBR
0163         %Contribucions als limits de Q i T2
0164         CLimQstd;%Q - Desviació tipica
0165         CLimQmea;%Q - Mitjana
0166         CLimT2std;%T2 - Desviació tipica
0167         CLimT2mea;%T2 - Mitjana
0168         
0169         ContMetode;%metode de calcular les contribucións (0 = descartar negatius i 1 = negatius i positius)
0170     end
0171 
0172 %-------------------------------------------------------------------------%
0173 %% ------------------DEFINICIO DE METODES DE LA CLASSE--------------------
0174 %-------------------------------------------------------------------------%
0175 
0176     methods
0177         
0178         %Els metodes descrits a continuació son publics i per tant
0179         %accesibles des de fora. Cal controlar el que s'ens passa per
0180         %parametre per evitar conflictes amb els tipus i/o formats de les
0181         %dades.
0182         
0183 %-------------------------------------------------------------------------%
0184 %%------------------------------CONSTRUCTORS------------------------------
0185 %-------------------------------------------------------------------------%
0186         
0187         %constructor per defecte, En el nostre cas al constructor se li
0188         %haura de passar un obgecte de tipus DATA, si no no es permetra
0189         %crear l'objecte.
0190         function obj = PCA(data)
0191             %Es el constructor per defecte de l'objecte. Demana un objecte
0192             %de tipus DATA per crear un objecte PCA, un PCA sense dades no
0193             %te cap sentit.
0194             %Carrega l'objecte DATA i Inicialitza tots els atributs de
0195             %l'objecte a buits. Fins que siguin necessaris.
0196             %
0197             %Parametres d'entrada:
0198             %
0199             %   data - un objecte de tipus DATA per poder crear el PCA
0200             %
0201             %Parametres de sortida:
0202             %
0203             %   obj - Retorna un objecte PCA inicialitzat per defecte
0204             %
0205             
0206             z=whos('data');
0207             if(strcmp( z.class , 'DATA'))
0208                 obj.DATA = data.copy();
0209                 obj.estandar=0;%fixem a no estandaritzades
0210                 obj.model=1;%es un model
0211                 obj.metode=1;%per defecte utilitzarem el metode de Kaiser
0212                 obj.metodee=1;%per defecte Auto Scaling
0213                 obj.treuFM=1;%per defecte treurem sempre la Forma mitja
0214                 obj.conv=0;%per defecte bach wide
0215                 obj.analitic=0;%per defecte 3 sigma
0216                 obj.ContMetode=0;
0217                 
0218                 obj.structura=[];
0219                 
0220                 %Borrem tot el que haviem calculat calculat
0221                 obj.Z=[];
0222                 obj.P=[];
0223                 obj.T=[];
0224                 obj.Landa=[];
0225                 obj.Landai=[];
0226                 obj.sta=[];
0227                 obj.mea=[];
0228                 obj.E=[];
0229                 obj.T2=[];
0230                 obj.LimT2=[];
0231                 obj.LimQ=[];
0232                 obj.Num=[];
0233                 obj.Num_save=[];
0234                 obj.CLimQstd=[];
0235                 obj.CLimQmea=[];
0236                 obj.CLimT2std=[];
0237                 obj.CLimT2mea=[];
0238                 
0239             else
0240                 disp('data must be a DATA object')
0241             end
0242         end
0243         %aquesta funció ens retorna una copia del nostre objecte.
0244         function copy = copy(obj)
0245             %Constructor de copia
0246             %Crea una copia del nostre objecte i el retorna per referencia
0247             %
0248             %Parametres d'entrada:
0249             %
0250             %   Aquest metode no te cap parametre d'entrada, obj es
0251             %   l'objecte actual i forma part de la OO de matlab.
0252             %
0253             %Parametres de sortida:
0254             %
0255             %   obj - Retorna un objecte PCA inicialitzat com a copia de
0256             %         l'actual
0257             %
0258             
0259             %Copiem les dades i creem un nou PCA per defecte
0260             copy=PCA(obj.DATA.copy);
0261             
0262             %El configurem com l'obvecte actual
0263             copy.estandar=obj.estandar;
0264             copy.model=obj.model;
0265             copy.metode=obj.metode;
0266             copy.metodee=obj.metodee;
0267             copy.treuFM=obj.treuFM;
0268             copy.conv=obj.conv;
0269             copy.analitic=obj.analitic;
0270             copy.ContMetode=obj.ContMetode;
0271             
0272             %tambe l'estructura per si s'utilitzava VRE
0273             copy.structura=obj.structura;
0274             
0275             
0276             %Copiem tot el que haviem calculat previament
0277             copy.Z=obj.Z;
0278             copy.P=obj.P;
0279             copy.T=obj.T;
0280             copy.Landa=obj.Landa;
0281             copy.Landai=obj.Landai;
0282             copy.sta=obj.sta;
0283             copy.mea=obj.mea;
0284             copy.E=obj.E;
0285             copy.T2=obj.T2;
0286             copy.LimT2=obj.LimT2;
0287             copy.LimQ=obj.LimQ;
0288             copy.Num=obj.Num;
0289             copy.CLimQstd=obj.CLimQstd;
0290             copy.CLimQmea= obj.CLimQmea;
0291             copy.CLimT2std=obj.CLimT2std;
0292             copy.CLimT2mea=obj.CLimT2mea;
0293             copy.Num_save=obj.Num_save;
0294             
0295         end
0296         
0297      
0298         
0299 %-------------------------------------------------------------------------%
0300 %% ------------------------- GETTERS AND SETTERS--------------------------
0301 %-------------------------------------------------------------------------%
0302         
0303         %Per trevallar amb les dades
0304         function obj = getRawData(obj)
0305             %Retorna les dades transformades a 2D utilitzant bach wide o
0306             %variable wide segons el metode indicat.
0307             %
0308             % Si metode = 0 o 'BW' Les dades es retornaran en format Bach wide
0309             % Si metode = 1 o 'VW' Les dades es retornaran en format Variable wide
0310             %
0311             %Parametres d'entrada:
0312             %
0313             %   metode - pot ser 1 , 0 , 'VW' o 'BW' i ens indica el format de converció
0314             %           a utilitzar
0315             %
0316             %Parametres de sortida:
0317             %
0318             %   obji - aquest metode retorna una matriu de doubles
0319             %         corresponent a l'unfolding de la matriu 3D on
0320             %         s'enmagatzemen les dades internament.
0321 
0322             obj = obj.DATA.getRawData(obj.conv);%cridem el metode adecuat del nostre objecte dades
0323         end
0324         function dades =getDATA(obj)
0325             %retorna una copia de l'objecte DATA de l'objecte actual
0326             %Parametres d'entrada:
0327             %
0328             %   Aquest metode no te cap parametre d'entrada
0329             %
0330             %Parametres de sortida:
0331             %
0332             %   obj - Retorna una copia de l'objecte que tenim assignat al
0333             %         nostre PCA com a dades
0334             %
0335             dades=obj.DATA.copy();%fem una copia i la retornem
0336         end
0337         %classes
0338         function clas=getClass(obj, i)
0339             %Retorna la classe de les dades
0340             %Parametres d'entrada:
0341             %
0342             %   No en te
0343             %
0344             %Parametres de sortida:
0345             %
0346             %   clas - Retorna un vector amb la classe de totes les dades
0347             %
0348              if nargin > 1
0349                 clas=obj.DATA.getClass(i);
0350             else
0351                 clas=obj.DATA.getClass();
0352              end
0353         end
0354         function setClass(obj,class)
0355             %Metode per donar classe a les dades d'un PCA
0356             %Parametres d'entrada:
0357             %
0358             %   class - La nova classe de les nostres dades
0359             %
0360             %Parametres de sortida:
0361             %
0362             %   No en te
0363             %
0364            obj.DATA.setClass(class); %passem la classe a l'objecte DATA perque ho guardi
0365         end
0366         %lots
0367         function deleteBatch(obj,i)
0368             %Treu els lots indexats per ''i". ''i" pot ser un double, o un
0369             %logical en format vector de 1 a n elements on n es el numero
0370             %de lots. O qualsebol format valid en indexacions al Matlab.
0371             %
0372             %
0373             % dim(1)=Temps
0374             % dim(2)=Variables
0375             % dim(3)=Batch
0376             %         _______
0377             %        |______ |                      _______
0378             %       |______ ||                     |______ |
0379             %      |______ |||                    |______ ||
0380             %  |  |       ||||     - [1] =    |  |       |||
0381             %Temps|       |||  /            Temps|       |||
0382             %  |  |       ||Batch             |  |       ||
0383             %     |_______|  /                   |_______|
0384             %     - Vars -                        - Vars -
0385             %
0386             %      Actual          index          Resultat
0387             % **recordar que el matlab les dimensions són 1-ordenades
0388             % 2-absices 3- profunditat**
0389             %
0390             %Parametres d'entrada:
0391             %
0392             %    i - els lots que es bol treure
0393             %
0394             %Parametres de sortida:
0395             %
0396             %   No en te
0397             %
0398             
0399             %treiem un lot de dades PCA s'ha de modificar
0400             if(obj.isModel)
0401                 %es un model
0402                 obj.estandar=0;%fixem a no estandaritzades
0403                 %Borrem tot el que haviem calculat calculat
0404                 obj.structura=[];
0405                 obj.Z=[];
0406                 obj.P=[];
0407                 obj.T=[];
0408                 obj.Landa=[];
0409                 obj.Landai=[];
0410                 obj.sta=[];
0411                 obj.mea=[];
0412                 obj.E=[];
0413                 obj.T2=[];
0414                 obj.LimT2=[];
0415                 obj.LimQ=[];
0416                 obj.Num=[];
0417                 obj.CLimQstd=[];
0418                 obj.CLimQmea=[];
0419                 obj.CLimT2std=[];
0420                 obj.CLimT2mea=[];
0421             else
0422                 %no es model
0423                 %aux=obj.DATA.getRawData3D();
0424                 %lots=size(aux,3);
0425                 
0426                 lots=obj.DATA.getBatchCount();
0427                 %vars=size(aux,2);%no necesitem
0428                 %temps=size(aux,1);
0429                 
0430                 temps = obj.DATA.getSampleCount();
0431                 %obj.structura=[];
0432                 if(obj.conv==0)
0433                     %bach wise
0434                     x=logical(1:lots);%x es un vector de 1 logics de longitud = al numero de lots
0435                     x(i)=0;%posem a 0 els que bolen eliminar
0436 
0437                     if(not(isempty(obj.Z)))
0438                         obj.Z=obj.Z(x,:);%lots*(vars*temps)
0439                     end
0440                     if(not(isempty(obj.T)))
0441                         obj.T=obj.T(x,:);%lots*(vars*temps)
0442                     end
0443                     if(not(isempty(obj.E)))
0444                         obj.E=obj.E(x,:);
0445                     end
0446                     if(not(isempty(obj.T2)))
0447                         obj.T2=obj.T2(x);
0448                     end
0449                     
0450                 else
0451                     %variable wise
0452                     x=logical(1:lots*temps);%x es un vector de 1 logics de longitud = al numero de lots
0453                     x(temps*(i-1)+(1:temps))=0;%posem a 0 els que bolen eliminar
0454                    
0455                     if(not(isempty(obj.Z)))
0456                         obj.Z=obj.Z(x,:);%(lots*temps)*vars
0457                     end
0458                     if(not(isempty(obj.T)))
0459                         obj.T=obj.T(x,:);%(lots*temps)*vars
0460                     end
0461                     if(not(isempty(obj.E)))
0462                         obj.E=obj.E(x,:);
0463                     end
0464                     if(not(isempty(obj.T2)))
0465                         obj.T2=obj.T2(x);
0466                     end
0467                 end
0468             end
0469             obj.DATA.deleteBatch(i);%treiem el lot de les dades
0470         end
0471         function addBatch(obj,dad, clase, nom)
0472             %Aquesta funció afegeix un o diversos Batch a les nostres
0473             %dades. Les mides del lot han de ser concordants amb les de la
0474             %resta de l'estructura que tenim.
0475             %                                                      _______
0476             % dim(1)=Temps                                        |______ |
0477             % dim(2)=Variables                                   |______ ||
0478             % dim(3)=Batch                                      |______ |||
0479             %         _______              _______             |______ ||||
0480             %        |______ |            |______ |           |______ ||||
0481             %       |______ ||           |______ ||          |______ ||||
0482             %      |______ |||   +      |______ |||     =   |______ ||||  /
0483             %  |  |       ||||      |  |       ||||     |  |       ||||  /
0484             %Temps|       |||  /  Temps|       |||    Temps|       |||Batch
0485             %  |  |       ||Batch   |  |       ||       |  |       ||  /
0486             %     |_______|  /         |_______|           |_______|  /
0487             %     - Vars -             - Vars -             - Vars -
0488             %
0489             %      Actual                 dad                 Resultat
0490             % **recordar que el matlab les dimensions són 1-ordenades
0491             % 2-absices 3- profunditat**
0492             %
0493             %Parametres d'entrada:
0494             %
0495             %    dad - matriu de doubles 2D o 3D
0496             %
0497             %    clase -  es un vector de doubles
0498             %
0499             %    ref - (opcional) es la referencia o nom del lot
0500             %
0501             %Parametres de sortida:
0502             %
0503             %   No en te
0504             %
0505             
0506             %afegim un nou lot de dades, PCA s'ha de modificar
0507             if(obj.isModel)
0508                 %es un model
0509                 obj.estandar=0;%fixem a no estandaritzades
0510                 %Borrem tot el que haviem calculat calculat
0511                 obj.structura=[];
0512                 obj.Z=[];
0513                 obj.P=[];
0514                 obj.T=[];
0515                 obj.Landa=[];
0516                 obj.Landai=[];
0517                 obj.sta=[];
0518                 obj.mea=[];
0519                 obj.E=[];
0520                 obj.T2=[];
0521                 obj.LimT2=[];
0522                 obj.LimQ=[];
0523                 obj.Num=[];
0524                 obj.CLimQstd=[];
0525                 obj.CLimQmea=[];
0526                 obj.CLimT2std=[];
0527                 obj.CLimT2mea=[];
0528             else
0529                 %no es model
0530                 aux=obj.DATA.copy();%muntem un nou objecte dades
0531                 aux.setRawData(dad);%li entrem les dades
0532                 aux.setClass(clase);
0533                 aux2=obj.project(aux);%el projectem al nostre model
0534                 %afegim les dades del nou lot a les actuals
0535                 if(not(isempty(aux2.Z)))
0536                     obj.Z=[obj.Z; aux2.getZ()];
0537                 else
0538                     error('no dades?');
0539                 end
0540                 if(not(isempty(aux2.T)))
0541                     obj.T=[obj.T; aux2.getT()];
0542                 else
0543                     obj.T=[];
0544                 end
0545                 if(not(isempty(aux2.E)))
0546                     obj.E=[obj.E; aux2.getE()];
0547                 else
0548                     obj.E=[];
0549                 end
0550                 if(not(isempty(aux2.T2)))
0551                     obj.T2=[obj.T2; aux2.getT2()];
0552                 else
0553                     obj.T2=[];
0554                 end
0555             end
0556             if nargin == 4
0557                 obj.DATA.addBatch(dad,clase,nom);
0558             else
0559                 obj.DATA.addBatch(dad,clase);
0560             end
0561         end
0562         function [data clas nom]=getBatch(obj, i)
0563             %retorna el lot o lots indicats per el parametre d'entrada 'i',
0564             %aquest por ser qualsebol tipus d'indexació valida en matlab.
0565             %
0566             %              _______
0567             %             |______ |
0568             %            |______ ||
0569             %           |______ |||
0570             %          |______ |||| - 8
0571             %         |______ |||| - 7
0572             %        |______ |||| - 6
0573             %       |______ |||| - 5   /
0574             %   |  |       |||| - 4   /
0575             % Temps|       ||| - 3 Batch
0576             %   |  |       || - 2   /
0577             %      |_______| - 1   /
0578             %      - Vars -
0579             %
0580             %
0581             %Parametres d'entrada:
0582             %
0583             %    i - index del lot/s que es vol recuperar
0584             %
0585             %Parametres de sortida:
0586             %
0587             %    data - matriu de doubles 2D son les dades del lot
0588             %
0589             %    clas -  es un double i correspon a la classe del lot
0590             %
0591             %    noms - es el nom del batch
0592             %
0593             
0594             %no afectara per res al PCA fem la crida a dades i prou
0595             [data clas nom]=obj.DATA.getBatch(i);
0596         end
0597         %dimencions
0598         function obji = getBatchCount(obj)
0599             %Retorna el numero de lots de les nostres dades
0600             %
0601             %Parametres d'entrada:
0602             %
0603             %   Aquest metode no te cap parametre d'entrada
0604             %
0605             %Parametres de sortida:
0606             %
0607             %   obji - es un double, correspon al nombre de lots del nostre
0608             %         objecte
0609             %
0610             
0611             obji = obj.DATA.getBatchCount();
0612         end
0613         function num = getVariableCount(obj)
0614             %Retorna el numero de variables de les nostres dades
0615             %
0616             %Parametres d'entrada:
0617             %
0618             %   Aquest metode no te cap parametre d'entrada
0619             %
0620             %Parametres de sortida:
0621             %
0622             %   num - es un double, correspon al nombre de variables del
0623             %         nostre objecte
0624             %
0625             num = obj.DATA.getVariableCount();
0626         end
0627         function num = getSampleCount(obj)
0628             %Retorna el numero de instants de temps de les nostres dades
0629             %
0630             %Parametres d'entrada:
0631             %
0632             %   Aquest metode no te cap parametre d'entrada
0633             %
0634             %Parametres de sortida:
0635             %
0636             %   num - es un double, correspon al nombre de instants de
0637             %         temps del nostre objecte
0638             %
0639             num = obj.DATA.getSampleCount();
0640         end
0641         %noms de lots
0642         function setBatchLabel(obj, in)
0643             %Fixara els noms dels lots. Aquests son els noms dels diferents
0644             %lots de les nodtres dades, se n'ha d'entra 1 per lot en el
0645             %mateix ordre en que els teim a les dades
0646             %
0647             %Parametres d'entrada:
0648             %
0649             %   variables - És el nou vector de noms dels lots.
0650             %               Aquest vector ha de ser un cellstring
0651             %
0652             %Parametres de sortida:
0653             %
0654             %   Aquest metode no te cap parametre de sortida
0655             %
0656             obj.DATA.setBatchLabel(in);
0657         end
0658         function out=getBatchLabel(obj,i)
0659             %retorna el nom dels lots. Aquests son els noms dels diferents
0660             %lots de les nodtres dades. Retornarem tots o nomes els que
0661             %s'ens indiqui.
0662             %
0663             %Parametres d'entrada:
0664             %
0665             %   i - (opcional)es l'index dels lots que volem recuperar-ne
0666             %       el nom, si no s'indica retornarem tots els noms
0667             %
0668             %Parametres de sortida:
0669             %
0670             %   out - És un cell string amb els noms indicats, sempre sera
0671             %         en format fila.
0672             %
0673             if nargin > 1
0674                 out=obj.DATA.getBatchLabel(i);
0675             else
0676                 out=obj.DATA.getBatchLabel();
0677             end
0678         end
0679         %Z
0680         function obj = getZ(obj)
0681             %Mčtode que retorna la matriu de dades estandaritzades i
0682             %desdoblades en BW o VW (en funció de com s’hagi creat el model
0683             %PCA).
0684             %
0685             %Parametres d'entrada:
0686             %
0687             %   Aquest metode no te cap parametre d'entrada
0688             %
0689             %Parametres de sortida:
0690             %
0691             %   obj - Retorna una matriu bidimencional
0692             %
0693             
0694             if(isempty(obj.Z) && obj.getBatchCount>0)%si no estan calculades les calculem
0695                 estandaritza(obj);
0696             end
0697             obj = obj.Z;%retornem les dades estandaritzades
0698         end
0699         %P;
0700         function obj = getP(obj)
0701             %Mčtode que retorna la matriu de dades estandaritzades i
0702             %desdoblades en BW o VW (en funció de com s’hagi creat el model
0703             %PCA).
0704             %
0705             %Parametres d'entrada:
0706             %
0707             %   Aquest metode no te cap parametre d'entrada
0708             %
0709             %Parametres de sortida:
0710             %
0711             %   obj - La matriu de components principals.
0712             %
0713             
0714             if(isempty(obj.P) && obj.getBatchCount>0)%si no estan calculades les calculem
0715                 obj.pca();%calculem T,P,...
0716             end
0717             obj = obj.P;%retornem les components principals
0718         end
0719         %T;
0720         function obj = getT(obj)
0721             %Mčtode que retorna la matriu que conté la projecció de les
0722             %dades en el subespai de les components principals.
0723             %
0724             %Parametres d'entrada:
0725             %
0726             %   Aquest metode no te cap parametre d'entrada
0727             %
0728             %Parametres de sortida:
0729             %
0730             %   obj - Retorna La matriu de T
0731             %
0732             if(isempty(obj.T) && obj.getBatchCount>0)%si no estan calculades les calculem
0733                 obj.pca();%calculem T,P...
0734             end
0735             obj = obj.T;%retornem T
0736         end
0737         %Landa;
0738         function obj = getLambda(obj)
0739             %Mčtode que retorna el vector de valors propis associats a les
0740             %components principals retingudes.
0741             %
0742             %Parametres d'entrada:
0743             %
0744             %   Aquest metode no te cap parametre d'entrada
0745             %
0746             %Parametres de sortida:
0747             %
0748             %   obj - Vector de doubles amb els valors propis associats a
0749             %         les components principals retingudes
0750             %
0751             
0752             if(isempty(obj.Landa) && obj.getBatchCount>0)%si no estan calculades les calculem
0753                 obj.pca();
0754             end
0755             obj = obj.Landa;
0756         end
0757         function obj = getLambdaAll(obj)
0758             %Mčtode que retorna el vector de valors propis associats a les
0759             %totes components principals (retingudes o no)
0760             %
0761             %Parametres d'entrada:
0762             %
0763             %   Aquest metode no te cap parametre d'entrada
0764             %
0765             %Parametres de sortida:
0766             %
0767             %   obj - Vector de doubles amb els valors propis associats a
0768             %         les components principals
0769             %
0770             
0771             if(isempty(obj.Landai) && obj.getBatchCount>0)%si no estan calculades les calculem
0772                 obj.pca();
0773             end
0774             obj = obj.Landai;
0775         end      
0776         %sta;
0777         function obj = getStd(obj)
0778             %Mčtode que retorna el vector de desviacions estŕndards per
0779             %estandaritzar les dades.
0780             %
0781             %Parametres d'entrada:
0782             %
0783             %   Aquest metode no te cap parametre d'entrada
0784             %
0785             %Parametres de sortida:
0786             %
0787             %   obj - Vector de doubles amb les desviacions estŕndards per
0788             %         estandaritzar les dades.
0789             %
0790             if(isempty(obj.sta) && obj.getBatchCount>0)%si no estan calculades les calculem
0791                 estandaritza(obj);
0792             end
0793             obj = obj.sta;
0794         end
0795         %mea;
0796         function obj = getMean(obj)
0797             %Mčtode que retorna la mitjana de les dades que s’utilitza per
0798             %estandaritzar les dades.
0799             %
0800             %Parametres d'entrada:
0801             %
0802             %   Aquest metode no te cap parametre d'entrada
0803             %
0804             %Parametres de sortida:
0805             %
0806             %   obj - Vector de doubles amb les mitjanes per estandaritzar
0807             %         les dades.
0808             %
0809             if(isempty(obj.mea) && obj.getBatchCount>0)%si no estan calculades les calculem
0810                 estandaritza(obj);
0811             end
0812             obj = obj.mea;
0813         end
0814         %E;
0815         function obj = getE(obj)
0816             %Mčtode que retorna la matriu residual.
0817             %Parametres d'entrada:
0818             %
0819             %   Aquest metode no te cap parametre d'entrada
0820             %
0821             %Parametres de sortida:
0822             %
0823             %   obj - Matriu 2D de doubles amb la matriu residual de la
0824             %         projecció.
0825             %
0826             if(isempty(obj.E) && obj.getBatchCount>0)%si no estan calculades les calculem
0827                 calculaE(obj);
0828             end
0829             obj = obj.E;
0830         end
0831         %getT2;
0832         function obj = getT2(obj)
0833             %Mčtode que retorna el vector de valors de l’índex T^2 per a
0834             %les dades projectades.
0835             %Parametres d'entrada:
0836             %
0837             %   Aquest metode no te cap parametre d'entrada
0838             %
0839             %Parametres de sortida:
0840             %
0841             %   obj - Vector de doubles que conté els valors de T^2 de les
0842             %         dades projectades.
0843             %
0844             if(isempty(obj.T2) && obj.getBatchCount>0)%si no estan calculades les calculem
0845                 %calculaLimT2(obj);
0846                 if(isempty(obj.T) && obj.getBatchCount>0)
0847                     obj.pca();
0848                 end
0849                 obj.T2=((obj.T).^2);
0850                 obj.T2=((obj.T2)./repmat(obj.Landa',size(obj.T2,1),1))*ones(size(obj.T2,2),1);
0851             end
0852             obj = obj.T2;
0853         end
0854         %LimT2
0855         function obj = getT2Limit(obj)
0856             %Mčtode que retorna el límit de de T^2. Qualsevol observació
0857             %amb un valor de T^2 superior a aquest valor es considera
0858             %defectuosa per T^2.
0859             %
0860             %Parametres d'entrada:
0861             %
0862             %   Aquest metode no te cap parametre d'entrada
0863             %
0864             %Parametres de sortida:
0865             %
0866             %   obj - Double amb el límit de T^2.
0867             %
0868             if(isempty(obj.LimT2)&& obj.getBatchCount>0)%si no estan calculades les calculem
0869                 calculaLimT2(obj);
0870             end
0871             obj = obj.LimT2();
0872         end
0873         %LimQ;
0874         function obj = getQLimit(obj)
0875             %Mčtode que retorna el límit de de Q. Qualsevol observació amb
0876             %un valor de Q superior a aquest valor es considera defectuosa
0877             %per Q.
0878             %
0879             %Parametres d'entrada:
0880             %
0881             %   Aquest metode no te cap parametre d'entrada
0882             %
0883             %Parametres de sortida:
0884             %
0885             %   obj - Retorna el limit per Q
0886             %
0887             if(isempty(obj.LimQ)&& obj.getBatchCount>0)%si no estan calculades les calculem
0888                 calculaLimQ(obj);
0889             end
0890             obj = obj.LimQ;
0891         end
0892         %Num;
0893         function obj = getNum(obj)
0894             %Mčtode que retorna el nombre de components principals retingudes.
0895             %
0896             %Parametres d'entrada:
0897             %
0898             %   Aquest metode no te cap parametre d'entrada
0899             %
0900             %Parametres de sortida:
0901             %
0902             %   obj - Double amb el nombre de components principals
0903             %         retingudes
0904             %
0905             if(isempty(obj.Num))
0906                 %si no s'ha inicialitzat el fixarem manualment
0907                 %disp('Encara no s`ha definit el nombre de components principals a utilitzar!');
0908                 %N=input('Entra el numero de components a utilitzar:');
0909                 N = str2double(inputdlg('Number of Principal componens to use:'));
0910                 z=whos('N');
0911                 while(~strcmp(z.class,'double'))
0912                     %N=input('Entra el numero de components a utilitzar:');
0913                     N = str2double(inputdlg('Number of Principal componens to use:'));
0914                     z=whos('N');
0915                 end
0916                 %el guarden
0917                 obj.Num=N;
0918                 obj.Num_save=N;
0919             end
0920             obj = obj.Num;
0921         end
0922         %fixem el numero de components principals
0923         function setNum(obj, n)
0924             %Mčtode que fixa el nombre de components principals a retenir
0925             %de manera manual.
0926             %
0927             %Parametres d'entrada:
0928             %
0929             %   n - double que indica el nombre de components principals a
0930             %       retenir
0931             %
0932             %Parametres de sortida:
0933             %
0934             %   No en te
0935             %
0936             
0937             %comprobem que ens passin un double
0938             z=whos('n');
0939             if(not(strcmp(z.class,'double')))
0940                 error('PCA/setNum: Waiting for double, no changes have been made.');
0941             end
0942             if(obj.model~=1)
0943                 error('PCA/setNum: Object must be model, no changes have been made.');
0944             end
0945             %El metode de selecció de components principals el canviem a
0946             %manual
0947             obj.metode = 0;
0948             obj.Num_save=n;%guardem el numero a la copia de seguretat
0949             if(n ~= obj.Num) %si es el mateix no fem res!
0950                 if(n < obj.Num)%si es mes petit no cal fer tans calculs!
0951                     obj.Num = n;
0952                     %nomes cal tallar
0953                     obj.P = obj.P(:, 1:(obj.Num));
0954                     obj.T = obj.T(:, 1:(obj.Num));
0955                     obj.Landa = obj.Landa(1:(obj.Num));
0956                     
0957                     obj.E=[];
0958                     obj.T2=[];
0959                     obj.LimT2=[];
0960                     obj.LimQ=[];
0961                     obj.CLimQstd=[];
0962                     obj.CLimQmea=[];
0963                     obj.CLimT2std=[];
0964                     obj.CLimT2mea=[];
0965                     
0966                     obj.structura=[];
0967                     
0968                 else
0969                     obj.Num = n;
0970 
0971                     %Borrem tot el que haviem calculat calculat
0972                     obj.P=[];
0973                     obj.T=[];
0974                     obj.Landa=[];
0975                     obj.Landai=[];
0976                     obj.E=[];
0977                     obj.T2=[];
0978                     obj.LimT2=[];
0979                     obj.LimQ=[];
0980                     obj.CLimQstd=[];
0981                     obj.CLimQmea=[];
0982                     obj.CLimT2std=[];
0983                     obj.CLimT2mea=[];
0984                     
0985                     obj.structura=[];
0986                     
0987                     obj.pca();
0988                 end
0989             end
0990         end
0991         %isModel
0992         function bool =isModel(obj)
0993             %Mčtode que indica si la instŕncia de PCA és un model (True) o
0994             %és una projecció (False).
0995             %
0996             %Parametres d'entrada:
0997             %
0998             %   Aquest metode no te cap parametre d'entrada
0999             %
1000             %Parametres de sortida:
1001             %
1002             %   obj - Boolea que indica si la instŕncia és un model PCA
1003             %         (True) o és una projecció (False).
1004             %
1005             bool=obj.model;
1006         end
1007         %Selecció components principals
1008         function metode =getPCSelectionMethod(obj)
1009             %Mčtode que retorna el procediment usat per determinar el
1010             %nombre de components principals.
1011             %Els possibles valors són:
1012             %   0 - Manual
1013             %   1 - Kaiser
1014             %   2 - Manual/Visual pel colze
1015             %   3 - Auto/Visual pel colze(proves)
1016             %   4 - Manual/Visual pel % d`explicacio de les dades
1017             %   5 - VRE
1018             %
1019             %Parametres d'entrada:
1020             %
1021             %   Aquest metode no te cap parametre d'entrada
1022             %
1023             %Parametres de sortida:
1024             %
1025             %   obj - Double que indica el mčtode amb quč s’ha determinat
1026             %         el nombre de components principals.
1027             %
1028             metode=obj.metode;
1029             
1030         end
1031         function setPCSelectionMethod(obj,x)
1032             %Mčtode que fixa el procediment a usar per determinar el
1033             %nombre de components principals.
1034             %Els possibles valors són:
1035             %   0 - Manual
1036             %   1 - Kaiser
1037             %   2 - Manual/Visual pel colze
1038             %   3 - Auto/Visual pel colze(proves)
1039             %   4 - Manual/Visual pel % d`explicacio de les dades
1040             %   5 - VRE
1041             %
1042             %Parametres d'entrada:
1043             %
1044             %   x - Double que indica el mčtode amb quč s’ha determinat
1045             %       el nombre de components principals.
1046             %
1047             %Parametres de sortida:
1048             %
1049             %   Aquest metode no te cap parametre de sortida
1050             %
1051             
1052             %comprovem el parametre d'entrada
1053             z=whos('x');
1054             if(not(strcmp(z.class,'double')))%tipus ha de ser double
1055                 error('PCA/setPCSelectionMethod: waiting for double, no changes have been made.');
1056             end
1057             if(not(0<=x && x<6))%comprovem el rang
1058                 error('PCA/setPCSelectionMethod: No valid selection method.');
1059             end
1060             if(not(obj.isModel()))%si no es model no es pot canviar
1061                 error('PCA/setPCSelectionMethod: No changes can be made in non model objects!');
1062             end
1063             
1064             %Si es el mateix k l'actual no cal fer res altrament borrar tot
1065             if(obj.metode~=x)
1066                 obj.structura=[];
1067                 
1068                 %Borrem tot el que haviem calculat calculat
1069                 obj.Z=[];
1070                 obj.P=[];
1071                 obj.T=[];
1072                 obj.Landa=[];
1073                 obj.Landai=[];
1074                 obj.sta=[];
1075                 obj.mea=[];
1076                 obj.E=[];
1077                 obj.T2=[];
1078                 obj.LimT2=[];
1079                 obj.LimQ=[];
1080                 obj.Num=[];
1081                 obj.CLimQstd=[];
1082                 obj.CLimQmea=[];
1083                 obj.CLimT2std=[];
1084                 obj.CLimT2mea=[];
1085                  obj.estandar=0;%fixem a no estandaritzades
1086             end
1087             %fixem el nou metode
1088             obj.metode=x;
1089             
1090             %missatge de VRE nomes funciona en VW!
1091             if(x==5 && obj.conv==0 )
1092                 warndlg('PCA/setPCSelectionMethod: VRE works only with Variable Wise.','ATTENTION!');
1093             end
1094         end
1095         %Estandardització
1096         function metode =getNormalizationMethod(obj)
1097             %Mčtode per saber el procés d’estandardització utilitzat.
1098             %Els valors possibles són:
1099             %
1100             %1 - Auto Scaling
1101             %2 - Group Scaling
1102             %3 - Continous Scaling
1103             %4 - Block Scaling
1104             %
1105             %Parametres d'entrada:
1106             %
1107             %   Aquest metode no te cap parametre d'entrada
1108             %
1109             %Parametres de sortida:
1110             %
1111             %   metode - es un double equivalent al metode utilitzat
1112             %
1113             metode=obj.metodee;
1114 
1115         end
1116         function setNormalizationMethod(obj,x)
1117             %Mčtode per fixar el procés d’estandardització.
1118             %Els valors vŕlids són:
1119             %
1120             %1 - Auto Scaling
1121             %2 - Group Scaling
1122             %3 - Continous Scaling
1123             %4 - Block Scaling
1124             %
1125             %Parametres d'entrada:
1126             %
1127             %   x - ha de ser de tipus double, sera el nou metode
1128             %   d'estandarització. Els valors possibles son:
1129             %       1 - Auto Scaling
1130             %       2 - Group Scaling
1131             %       3 - Continous Scaling
1132             %       4 - Block Skaling
1133             %
1134             %Parametres de sortida:
1135             %
1136             %   No en te
1137             %
1138             z=whos('x');
1139             if(not(strcmp(z.class,'double')))
1140                 error('PCA/setNormalizationMethod: Waiting for double, no changes have been made.');
1141             end
1142             if(not(1<=x && x<=4))
1143                 error('PCA/setNormalizationMethod: No valid estandaritzation method.');
1144             end
1145              if(not(obj.isModel()))
1146                 error('PCA/setNormalizationMethod: No changes can be made in non model objects!');
1147             end
1148             if(obj.metodee~=x)
1149                 obj.structura=[];
1150                 
1151                 %Borrem tot el que haviem calculat calculat
1152                 obj.Z=[];
1153                 obj.P=[];
1154                 obj.T=[];
1155                 obj.Landa=[];
1156                 obj.Landai=[];
1157                 obj.sta=[];
1158                 obj.mea=[];
1159                 obj.E=[];
1160                 obj.T2=[];
1161                 obj.LimT2=[];
1162                 obj.LimQ=[];
1163                 obj.Num=[];
1164                 obj.CLimQstd=[];
1165                 obj.CLimQmea=[];
1166                 obj.CLimT2std=[];
1167                 obj.CLimT2mea=[];
1168                  obj.estandar=0;%fixem a no estandaritzades
1169             end
1170             
1171             obj.metodee=x;
1172             
1173         end
1174         %treure la forma mitja
1175         function setTrajectoryRemoval(obj,x)
1176             %Mčtode per indicar si s’ha de treure la forma mitja (x =True)
1177             %o no (x = False) durant el procés d’estandardització.
1178             %
1179             %Parametres d'entrada:
1180             %
1181             %   x - ha de ser de tipus double, s'espera un 1 o un 0, si es
1182             %   1 forçarem treure la forma mitja de les dades.
1183             %
1184             %Parametres de sortida:
1185             %
1186             %   No en te
1187             %
1188             z=whos('x');
1189             if(not(strcmp(z.class,'double')))
1190                 error('PCA/setTrajectoryRemoval: Waiting for double, no changes have been made.');
1191             end
1192             if(not(0<=x && x<=1))
1193                 error('PCA/setTrajectoryRemoval: Only is allowed 1 or 0');
1194             end
1195             if(not(obj.isModel()))
1196                 error('PCA/setTrajectoryRemoval: No changes can be made in non model objects!');
1197             end
1198             if(obj.treuFM~=x)
1199                 obj.structura=[];
1200                 
1201                 %Borrem tot el que haviem calculat calculat
1202                 obj.Z=[];
1203                 obj.P=[];
1204                 obj.T=[];
1205                 obj.Landa=[];
1206                 obj.Landai=[];
1207                 obj.sta=[];
1208                 obj.mea=[];
1209                 obj.E=[];
1210                 obj.T2=[];
1211                 obj.LimT2=[];
1212                 obj.LimQ=[];
1213                 obj.Num=[];
1214                 obj.CLimQstd=[];
1215                 obj.CLimQmea=[];
1216                 obj.CLimT2std=[];
1217                 obj.CLimT2mea=[];
1218                  obj.estandar=0;%fixem a no estandaritzades
1219             end
1220             
1221             obj.treuFM=x;
1222             
1223         end
1224         function val =getTrajectoryRemoval(obj)
1225             %Mčtode per indicar si s’ha tret la forma mitja (val =True) o
1226             %no (val = False) durant el procés d’estandardització.
1227             %
1228             %Parametres d'entrada:
1229             %
1230             %   No en te
1231             %
1232             %Parametres de sortida:
1233             %
1234             %   val - es de tipus double, 1 o 0, si es 1 indica que s'ha
1235             %         tret la forma mitja de les dades altament no s'haura
1236             %         tret
1237             %
1238             val = obj.treuFM;
1239         end
1240         %setUnfoldingMethod
1241         function setUnfoldingMethod(obj,x)
1242             %Mčtode per fixar el tipus de desdoblament.
1243             %1= VW i 0=BW
1244             %Parametres d'entrada:
1245             %
1246             %   x - ha de ser de tipus double, s'espera un 1 o un 0, si es
1247             %   1 apartir d'ara trevallarem en VW si es un 0 trevallarem en
1248             %   BW
1249             %
1250             %Parametres de sortida:
1251             %
1252             %   No en te
1253             %
1254             z=whos('x');
1255             if(not(strcmp(z.class,'double')))
1256                 error('PCA/setUnfoldingMethod: Waiting for double, no changes have been made.');
1257             end
1258             if(not(0<=x && x<=1))
1259                 error('PCA/setUnfoldingMethod: Only is allowed 1 or 0');
1260             end
1261             if(not(obj.isModel()))
1262                 error('PCA/setUnfoldingMethod: No changes can be made in non model objects!');
1263             end
1264             if(obj.conv~=x)
1265                 obj.structura=[];
1266                 
1267                 %Borrem tot el que haviem calculat calculat
1268                 obj.Z=[];
1269                 obj.P=[];
1270                 obj.T=[];
1271                 obj.Landa=[];
1272                 obj.Landai=[];
1273                 obj.sta=[];
1274                 obj.mea=[];
1275                 obj.E=[];
1276                 obj.T2=[];
1277                 obj.LimT2=[];
1278                 obj.LimQ=[];
1279                 obj.Num=[];
1280                 obj.CLimQstd=[];
1281                 obj.CLimQmea=[];
1282                 obj.CLimT2std=[];
1283                 obj.CLimT2mea=[];
1284                  obj.estandar=0;%fixem a no estandaritzades
1285             end
1286             
1287             obj.conv= x;
1288         end
1289         function obj = getUnfoldingMethod(obj)
1290             %Metode que retorna el metode d'unfolding que s'ha utilitzat
1291             %1= VW i 0=BW
1292             %Parametres d'entrada:
1293             %
1294             %   No en te
1295             %
1296             %Parametres de sortida:
1297             %
1298             %   obj - Retorna el metode d'unfolding utilitzat 1= VW i 0=BW.
1299             %
1300             obj = obj.conv;
1301         end
1302         %Metode calcul Limits
1303         function setLimitMethod(obj,x)
1304             %Metode per fixar el metode que utilitzarem per calcular els
1305             %limits 1=analitic  i 0= 3 sigma(per defecte)
1306             %
1307             %Parametres d'entrada:
1308             %
1309             %   x - ha de ser de tipus double, s'espera un 1 o un 0, si es
1310             %   1 apartir d'ara calcularem els limits analiticament, si es
1311             %   0 es calcularan amb 3 sigma.
1312             %
1313             %Parametres de sortida:
1314             %
1315             %   No en te
1316             %
1317             z=whos('x');
1318             if(not(strcmp(z.class,'double')))
1319                 error('PCA/setLimitMethod: Waiting for double, no changes have been made.');
1320             end
1321             if(not(0<=x && x<=1))
1322                 error('PCA/setLimitMethod: Only is allowed 1 or 0');
1323             end
1324             if(not(obj.isModel()))
1325                 error('PCA/setUnfoldingMethod: No changes can be made in non model objects!');
1326             end
1327             if(obj.analitic~=x)
1328                 %obj.structura=[];
1329                 
1330                 %Borrem tot el que haviem calculat calculat
1331                 %obj.Z=[];
1332                 %obj.P=[];
1333                 %obj.T=[];
1334                 %obj.Landa=[];
1335                 %obj.Landai=[];
1336                 %obj.sta=[];
1337                 %obj.mea=[];
1338                 %obj.E=[];
1339                 %obj.T2=[];
1340                 obj.LimT2=[];
1341                 obj.LimQ=[];
1342                 %obj.Num=[];
1343                 obj.CLimQstd=[];
1344                 obj.CLimQmea=[];
1345                 obj.CLimT2std=[];
1346                 obj.CLimT2mea=[];
1347             end
1348             obj.analitic= x;
1349         end
1350         function x = getLimitMethod(obj)
1351             %Metode per fixar el metode que utilitzarem per calcular els
1352             %limits 1=analitic  i 0= 3 sigma(per defecte)
1353             %Parametres d'entrada:
1354             %
1355             %   No en te
1356             %
1357             %Parametres de sortida:
1358             %
1359             %   x - Es un 1 o un 0, si es ens indica el metode que s'esta
1360             %   utilitzant per calcular els limits 1 = analitic 0= 3 sigma
1361             %
1362             x = obj.analitic;
1363         end
1364         %fixa el metode de calcular contribucións
1365         function setContributionMethod(obj,x)
1366             %metode per fixar el metode de calcul de les contribucións, en
1367             %cas d'indicar 0 = descartar negatius i 1 = negatius i positius
1368             %
1369             %Parametres d'entrada:
1370             %
1371             %   x - ha de ser de tipus double, s'espera un 1 o un 0
1372             %       0 = descartar negatius
1373             %       1 = negatius i positius
1374             %
1375             %Parametres de sortida:
1376             %
1377             %   No en te
1378             %
1379             if x ~= 1 && x ~= 0
1380                 error('PCA/setContributionMethod: Waiting for double, no changes have been made.');
1381             end
1382             if obj.model ~= 1
1383                 error('PCA/setContributionMethod: No changes can be made in non model objects!');
1384             end
1385             
1386             obj.ContMetode=x;
1387             
1388             %m'han canviat el metode de calcular les contribucións les
1389             %borrem perke poden no ser correctes
1390             obj.CLimQstd=[];
1391             obj.CLimQmea=[];
1392             obj.CLimT2std=[];
1393             obj.CLimT2mea=[];
1394         end
1395         function x = getContMetode(obj)
1396             %Metode per saver el metode de calcul de les contribucións, en
1397             %cas de retornat 0 = descartar negatius i 1 = negatius i positius
1398             %
1399             %Parametres d'entrada:
1400             %
1401             %   No en te
1402             %
1403             %Parametres de sortida:
1404             %
1405             %   x - Es de tipus double, s'espera un 1 o un 0
1406             %       0 = descartar negatius
1407             %       1 = negatius i positius
1408             %
1409             x = obj.ContMetode;
1410         end
1411         %getQ
1412         function obj = getQ(obj)
1413             %Mčtode que retorna el vector amb els valors de Q de les dades
1414             %projectades.
1415             %
1416             %Parametres d'entrada:
1417             %
1418             %   No en te
1419             %
1420             %Parametres de sortida:
1421             %
1422             %   obj - Vector de dades amb els valors de Q per a cadascuna
1423             %         de les observacions.
1424             %
1425             
1426             if(isempty(obj.E) && obj.getBatchCount>0)%si no estan calculades les calculem
1427                 calculaE(obj);
1428             end
1429             %Retorna les dades.
1430             obj = ((obj.E).^2)*ones(size(obj.E,2),1);
1431         end
1432         %get contribucio de Q
1433         function sort = getQContribution(obj)
1434             %Mčtode que retorna les contribucions de cada observació i
1435             %variable de l’índex Q.
1436             %Parametres d'entrada:
1437             %
1438             %   No en te
1439             %
1440             %Parametres de sortida:
1441             %
1442             %   sort - Matriu de doubles amb les contribucions de Q per
1443             %          cada observació i variable.
1444             %
1445 
1446             %Retorna les dades.
1447             sort = calculaContQ(obj);
1448         end 
1449         %get contribucio de T^2
1450         function sort = getT2Contribution(obj)
1451             %Mčtode que retorna les contribucions de cada observació i
1452             %variable de l’índex T^2.
1453             %Parametres d'entrada:
1454             %
1455             %   No en te
1456             %
1457             %Parametres de sortida:
1458             %
1459             %   sort - Matriu de doubles amb les contribucions de T^2 per
1460             %   cada observació i variable.
1461             %
1462             sort = calculaContT2(obj);
1463         end
1464         %get contribucio de limit Q mea
1465         function obj = getQContributionLimitMean(obj)
1466             %Mčtode que retorna la mitjana de les contribucions de Q per
1467             %cada variable que s’utilitza per al cŕlcul del límit de les
1468             %contribucions de Q.
1469             %
1470             %Parametres d'entrada:
1471             %
1472             %   No en te
1473             %
1474             %Parametres de sortida:
1475             %
1476             %   obj - Vector de doubles amb la mitjana de les contribucions
1477             %         de Q.
1478             %
1479             if(isempty(obj.CLimQmea))%si no estan calculades les calculem
1480                 calculaContQ(obj);
1481             end
1482 
1483                 obj=obj.CLimQmea;
1484         end
1485         %get contribucio de limit Q std
1486         function obj = getQContributionLimitStd(obj)
1487             %Mčtode que retorna la desviació estŕndard de les contribucions
1488             %de Q per cada variable que s’utilitza per al cŕlcul del límit
1489             %de les contribucions de Q.
1490             %
1491             %Parametres d'entrada:
1492             %
1493             %   No en te
1494             %
1495             %Parametres de sortida:
1496             %
1497             %   obj - Vector de doubles amb les desviacions estŕndards de
1498             %         les contribucions de Q.
1499             %
1500             if(isempty(obj.CLimQstd))%si no estan calculades les calculem
1501                 calculaContQ(obj);
1502             end
1503 
1504                 obj=obj.CLimQstd;
1505         end
1506         %get contribucio de limit T^2 mea
1507         function obj = getT2ContributionLimitMean(obj)
1508             %Mčtode que retorna la mitjana de les contribucions de T^2 per
1509             %cada variable que s’utilitza per al cŕlcul del límit de les
1510             %contribucions de T^2.
1511             %Parametres d'entrada:
1512             %
1513             %   No en te
1514             %
1515             %Parametres de sortida:
1516             %
1517             %   obj - Vector de doubles amb la mitjana de les contribucions
1518             %         de T^2
1519             %
1520             if(isempty(obj.CLimT2mea))%si no estan calculades les calculem
1521                 calculaContT2(obj);
1522             end
1523 
1524                 obj=obj.CLimT2mea;
1525         end
1526         %get contribucio de limit T^2 std
1527         function obj = getT2ContributionLimitStd(obj)
1528             %Mčtode que retorna la desviació estŕndard de les contribucions
1529             %de T^2 per cada variable que s’utilitza per al cŕlcul del
1530             %límit de les contribucions de T^2.
1531             %
1532             %Parametres d'entrada:
1533             %
1534             %   No en te
1535             %
1536             %Parametres de sortida:
1537             %
1538             %   obj - Vector de doubles amb les desviacions estŕndards de
1539             %         les contribucions de T^2.
1540             %
1541             if(isempty(obj.CLimT2std))%si no estan calculades les calculem
1542                 calculaContT2(obj);
1543             end
1544 
1545                 obj=obj.CLimT2std;
1546         end
1547         %crea fitxer pel weka
1548         function weka(obj,nomfitx)
1549             %Mčtode que crea un fitxer ,i l’anomenara i posicionarŕ segons
1550             %l’string que contingui nomfitx,on es posen les dades
1551             %necessŕries per entrar la base de casos al weka.
1552             %
1553             %Parametres d'entrada:
1554             %
1555             %   nomfitx - String amb el nom del fitxer (i opcionalment la
1556             %             ruta)
1557             %
1558             %Parametres de sortida:
1559             %
1560             %   Creara un fitxer anomenat 'nomfitx'.arff i hi posara les
1561             %   dades necesaries per entrar la base de casos al weka.
1562             %
1563             aux=obj.foraCQ;
1564             celles=obj.DATA.getClass();
1565             aux = [aux'; celles];
1566              if isempty(strfind(nomfitx,'.arff'))
1567                 nomfitx = strcat(nomfitx,'.arff');
1568              end
1569             new_file = fopen(nomfitx,'w');
1570             
1571             fprintf(new_file,'@RELATION %s \r\n',obj.DATA.getName());
1572             
1573             for x = 1:length(obj.DATA.getVariableLabel)
1574                 for y = 1:length(obj.DATA.getStages)
1575                     fprintf(new_file,'@ATTRIBUTE %s_%s NUMERIC\r\n',obj.DATA.getVariableLabel{x},obj.DATA.getStages{y});
1576                 end
1577             end
1578             
1579             fprintf(new_file,'@ATTRIBUTE class NUMERIC\r\n');
1580             %fprintf(new_file,'%%1=bo\n%%0=regular\n%%-1=dolent\n');
1581             fprintf(new_file,'@DATA\r\n');
1582             fclose(new_file);
1583             
1584             dlmwrite(nomfitx,aux,'-append','newline','pc');
1585         end
1586         %reconstruct si s'ha fet CBA
1587         function [x_rec, f_i, direccio, valid] = reconstruct(obj)
1588             %Si s'ha utilitzat VRE fa una reconstruccio per recuperar les
1589             %dades originals. Aquesta funcio es privada.
1590             if obj.metode==5 && obj.conv==1 %si (CBR I VW){
1591                 %si s'ha utilitzat VRE i estem en VW es pot fer
1592                 if(isempty(obj.P))%si no estan calculades les calculem
1593                     obj.pca();
1594                 end
1595             
1596 % | X:          Array or matrix of double values whose observations       |
1597 % |             (rows) have to be reconstructed (if their square          |
1598 % |             prediction error surpasses the statistical limit of the   |
1599 % |             PCA model).                                               |
1600 % | PCA_Struct:    Structure that contains the information required to       |
1601 % |             project new observations to a given principal component   |
1602 % |             analysis (PCA) model. This structure must have, at least: |
1603 % |             -> mx: array containing the mean for each variable        |
1604 % |             (column) to subtract to X.                                |
1605 % |             -> std: array containing the standard deviation of each   |
1606 % |             variables (column) in X. This value is used to rescalate  |
1607 % |             (divide) each variable.                                   |
1608 % |             -> P: matrix containing the weights (loadings) to project |
1609 % |             each observation (row) in X to the PCA model.             |
1610 % |             -> SPE_lim: statistical limit for the SPE. This value is  |
1611 % |             used to determine if an observation (row) in X is faulty  |
1612 % |             (greater than SPE_lim) or not (equal or lower).           |
1613 X=obj.Z;
1614 MPCA_struc= struct('mx',obj.getMean,'std',obj.getStd,'P',obj.getP,'SPE_lim',obj.getQLimit,'lambda',obj.getLambda,'T2_lim',obj.getT2Limit,'R',(X'*X)/(size(X,1)-1));
1615                 [f_i, direccio, x_rec] = VRE_fault_rec(X, MPCA_struc);
1616                 valid=f_i==0;
1617 
1618             else
1619                 %no es pot fer
1620                 disp('RECONSTRUCTION FAILED');
1621             end
1622         end
1623         %Funció per treure outliers del Model.
1624         function canvis = deleteOutLiers(obj,alt)
1625             %Metode que elimina els outliers per T^2 i Q del model dins de
1626             %cada classe. amb el parametre alt podem selecciónar si bolem
1627             %eliminar-los tots o només els extrems.
1628             %
1629             % +-1.5 * RIQ per trobar tots els outliers (alt {'all' 'ALL' 'All'})
1630             %
1631             % +-2.75 * RIQ per trobar nomes els extrems (Opció per defecte)
1632             %
1633             %Parametres d'entrada:
1634             %
1635             %   alt - (opcional) indicant un dels strings {'all' 'ALL'
1636             %          'All'} s'eliminaran outliers amb +-1.5 * RIQ
1637             %          altrament es fara amb +-2.75 * RIQ
1638             %
1639             %Parametres de sortida:
1640             %
1641             %   canvis - indica si hi ha hagut canvis (si hi ha canvis pot
1642             %            haver-hi nous outliers)
1643             %
1644             if(obj.isModel)
1645                 %mostrem la distribució de les dades inicials
1646                 if(obj.conv == 1)
1647                     error('PCA/deleteOutLiers: can not be used in Variable Wise.');
1648                 end
1649                 
1650                 if nargin == 1
1651                     ind = getOutLiers(obj);
1652                 else
1653                     ind = getOutLiers(obj,alt);
1654                 end
1655                 obj.deleteBatch(ind);
1656                 
1657                 %indica el numero de lots que hem tret
1658                 canvis = sum(ind);
1659                 
1660             else
1661                 %no es un model. No podem modificar les dades dels PCA No
1662                 %model perque depenen del Model al qual s'han projectat.
1663                  
1664                 error('PCA/deleteOutLiers: The object must be a Model.');
1665                 
1666             end
1667         end
1668         %Funció que comprova si hi ha outliers
1669         function outs = getOutLiers(obj,alt)
1670             %Metode que detecta els outliers per T^2 i Q del model dins de
1671             %cada classe. amb el parametre alt podem selecciónar si bolem
1672             %detectar-los tots o només els extrems.
1673             %
1674             % +-1.5 * RIQ per trobar tots els outliers (alt {'all' 'ALL' 'All'})
1675             %
1676             % +-2.75 * RIQ per trobar nomes els extrems (Opció per defecte)
1677             %
1678             %Parametres d'entrada:
1679             %
1680             %   alt - (opcional) indicant un dels strings {'all' 'ALL'
1681             %          'All'} es detectaran outliers amb +-1.5 * RIQ
1682             %          altrament es fara amb +-2.75 * RIQ
1683             %
1684             %Parametres de sortida:
1685             %
1686             %   outs - les posicions dels outliers
1687             %
1688             if nargin ==2
1689                switch alt
1690                    case {'all' 'ALL' 'All'}
1691                        %no fer res!
1692                    otherwise
1693                        %ha de fer el mateix que si nomes ens passesin 1
1694                        %parametre
1695                        alt = [];
1696                end
1697             end
1698             
1699             if nargin ==1
1700                  alt = [];
1701             end
1702             
1703             if(obj.isModel)
1704                 
1705                 if(obj.conv == 1)
1706                     error('PCA/getOutLiers: can not be used in Variable Wise.');
1707                 end
1708                 cl = obj.getClass;
1709                 for i = unique(cl)
1710                     index = (cl == i);
1711                     
1712                     %Treiem els outliers de manera automatica.
1713                     Qs=obj.getQ;
1714                     Ts=obj.getT2();
1715                     
1716                     %Treiem outliers per Q
1717                     %primer de tot calculem els quartils
1718                     qrts = prctile(Qs(index),[25 75]);
1719                     
1720                     %calculem el rang interquartilic
1721                     IRQ = qrts(2) - qrts(1);
1722                     
1723                     if isempty(alt)
1724                         %afegim el +-2.75 * RIQ per trobar els extrems
1725                         qrts(1) = qrts(1) - 2.75*IRQ;
1726                         qrts(2) = qrts(2) + 2.75*IRQ;
1727                     else
1728                         %afegim el +-RIQ per trobar els outliers
1729                         qrts(1) = qrts(1) - 1.5*IRQ;
1730                         qrts(2) = qrts(2) + 1.5*IRQ;
1731                     end
1732                     
1733                     %Calculem els outliers per Q i els guardem a ind
1734                     ind1 = or(Qs < qrts(1) , Qs > qrts(2));
1735                     
1736                     %tots els que son outliers de classes diferents de la que
1737                     %toca en realitat no ho son!
1738                     ind1(~index) = 0;
1739                     
1740                     
1741                     
1742                     
1743                     %Treiem outliers per T^2
1744                     %primer de tot calculem els quartils
1745                     qrts = prctile(Ts(index),[25 75]);
1746                     
1747                     %calculem el rang interquartilic
1748                     IRQ = qrts(2) - qrts(1);
1749                     
1750                     if isempty(alt)
1751                         %afegim el +-2.75 * RIQ per trobar els extrems
1752                         qrts(1) = qrts(1) - 2.75*IRQ;
1753                         qrts(2) = qrts(2) + 2.75*IRQ;
1754                     else
1755                         %afegim el +-RIQ per trobar els outliers
1756                         qrts(1) = qrts(1) - 1.5*IRQ;
1757                         qrts(2) = qrts(2) + 1.5*IRQ;
1758                     end
1759                     
1760                     %treiem els outliers extrems
1761                     ind = or(Ts < qrts(1) , Ts > qrts(2));
1762                     ind(~index) = 0;
1763                     
1764                     ant{i}= or(ind,ind1);
1765                     
1766                 end
1767                 
1768                 outs = [ant{:}];
1769                 outs= sum(outs,2);
1770                 outs = outs >= 1;
1771                 
1772             else
1773                 %no es un model. No podem modificar les dades dels PCA No
1774                 %model perque depenen del Model al qual s'han projectat.
1775                 
1776                 error('PCA/getOutLiers: The object must be a Model.');
1777                 
1778             end
1779         end
1780  
1781 %-------------------------------------------------------------------------%
1782 %% ------------------------------- ALTRES --------------------------------
1783 %-------------------------------------------------------------------------%
1784         
1785         %PCA
1786         function [a b c] = pca(obj)
1787             %Mčtode que retorna la informació relacionada amb el model PCA.
1788             %Parametres d'entrada:
1789             %
1790             %   No en te
1791             %
1792             %Parametres de sortida:
1793             %
1794             %   a - Matriu de doubles que conté les components principals retingudes
1795             %   b - Matriu de doubles amb les projeccions de les observacions al subespai de components principals.
1796             %   c - Vector de doubles amb els valors propis associats a les components principals retingudes
1797             %
1798             
1799             if(~obj.isModel())
1800                 errordlg('PCA\pca: You can''t use this method ober a non model object!','error');
1801             end
1802             
1803             if(isempty(obj.P)|| (isempty(obj.T) && obj.getBatchCount>0) || isempty(obj.Landa))
1804                 %si no s'ha fet encara cap cop pca el fem
1805                 if(obj.estandar~=1)
1806                     %estandaritzem les dades si cal
1807                     estandaritza(obj);
1808                 end
1809                 
1810                 %ens quedem amb el numero de components principals que
1811                 %necesitem segons el cas
1812                 
1813                 %comentat per poder assignar manualment el numero de
1814                 %components principals amb el metode setNum i no haver de
1815                 %fer el popup sempre.
1816 %                if(isempty(obj.Num))%no s'ha fixat el numero de components principals que bolem
1817                     
1818                     switch obj.metode
1819                         case 0
1820                             %si no s'ha definit cap numero de components
1821                             %principals fem que l'usuari l'entri manualment
1822                             
1823                             
1824 %
1825 %                             r=obj.Z'*obj.Z/(size(obj.Z,1)-1);
1826 %                             [V, D] = eig(r);
1827 %                             obj.Landa=flipud(diag(D));
1828 %                             obj.P=fliplr(V);
1829 %                             obj.T=obj.Z*obj.P;
1830 
1831                             %if exist('princomp')
1832                             if license('test','statistics_toolbox')%mes eficient que l'exists
1833                                 [obj.P obj.T obj.Landa]=princomp(obj.Z);
1834                             else
1835                                 r=obj.Z'*obj.Z/(size(obj.Z,1)-1);
1836                                 [~,D,obj.P]=svd(r,'econ');
1837                                 obj.Landa=diag(D);
1838                                 obj.T=obj.Z*obj.P;
1839                             end
1840                             if(isempty(obj.Num))
1841                                 if isempty(obj.Num_save)
1842                                     getNum(obj);
1843                                 else
1844                                     obj.Num = obj.Num_save;
1845                                 end
1846                             end
1847                         case 1
1848                             %toca fer KAiser
1849 %[obj.P obj.T obj.Landa]=princomp(obj.Z);
1850                             %toca fer GrafScree
1851                             %if exist('princomp')
1852                             if license('test','statistics_toolbox')%mes eficient que l'exists
1853                                 [obj.P obj.T obj.Landa]=princomp(obj.Z);
1854                             else
1855                                 r=obj.Z'*obj.Z/(size(obj.Z,1)-1);
1856                                 [~,D,obj.P]=svd(r,'econ');
1857                                 obj.Landa=diag(D);
1858                                 obj.T=obj.Z*obj.P;
1859                             end
1860                             cDKaiser(obj);
1861                         case 2
1862                             %toca fer GrafScree
1863                             %if exist('princomp')
1864                             if license('test','statistics_toolbox')%mes eficient que l'exists
1865                                 [obj.P obj.T obj.Landa]=princomp(obj.Z);
1866                             else
1867                                 r=obj.Z'*obj.Z/(size(obj.Z,1)-1);
1868                                 [~,D,obj.P]=svd(r,'econ');
1869                                 obj.Landa=diag(D);
1870                                 obj.T=obj.Z*obj.P;
1871                             end
1872                             cGrafscree(obj);
1873                         case 3
1874                             %colze analitic
1875                             %if exist('princomp')
1876                             if license('test','statistics_toolbox')%mes eficient que l'exists
1877                                 [obj.P obj.T obj.Landa]=princomp(obj.Z);
1878                             else
1879                                 r=obj.Z'*obj.Z/(size(obj.Z,1)-1);
1880                                 [~,D,obj.P]=svd(r,'econ');
1881                                 obj.Landa=diag(D);
1882                                 obj.T=obj.Z*obj.P;
1883                             end
1884                             colzeanalitic(obj);
1885                         case 4
1886                             %toca % variança
1887                             %if exist('princomp')
1888                             if license('test','statistics_toolbox')%mes eficient que l'exists
1889                                 [obj.P obj.T obj.Landa]=princomp(obj.Z);
1890                             else
1891                                 r=obj.Z'*obj.Z/(size(obj.Z,1)-1);
1892                                 [~,D,obj.P]=svd(r,'econ');
1893                                 obj.Landa=diag(D);
1894                                 obj.T=obj.Z*obj.P;
1895                             end
1896                             cVarExp(obj);
1897                         case 5
1898                             %VRE
1899                             obj.structura=variance_reconstruction_error(obj.Z,eye(size(obj.Z,2)));
1900                             obj.Num=obj.structura.l_rec{obj.structura.n_loops};
1901                             obj.Z=obj.structura.X_rec{obj.structura.n_loops};
1902                             r=obj.Z'*obj.Z/(size(obj.Z,1)-1);
1903                             [V, D] = eig(r);
1904                             obj.Landa=flipud(diag(D));
1905                             obj.P=fliplr(V);
1906                             obj.T=obj.Z*obj.P;
1907                         otherwise
1908                             error('PCA\pca: Invalid component selection method')
1909                     end
1910 
1911 %                end
1912                 
1913                 %agafem les dades que necesitem i la resta les eliminem
1914                 obj.P = obj.P(:, 1:(obj.Num));
1915                 obj.T = obj.T(:, 1:(obj.Num));
1916                 obj.Landai=obj.Landa;
1917                 obj.Landa = obj.Landa(1:(obj.Num));
1918                 
1919             end
1920             if nargout ~= 0
1921             %retornem les dades demanades
1922             a=obj.P;
1923             b=obj.T;
1924             c=obj.Landa;
1925             end
1926         end
1927         %Projecta - crea un PCA no model a partir d'unes dades
1928         function nou = project(obj,x)
1929             %Mčtode que projecta un objecte DATA sobre el model PCA. Es
1930             %retorna un nou objecte PCA amb la informació corresponent de
1931             %les dades projectades.
1932             %
1933             %Parametres d'entrada:
1934             %
1935             %   x - Objecte DATA amb la informació quč es vol projectar
1936             %       sobre el model PCA.
1937             %
1938             %Parametres de sortida:
1939             %
1940             %   nou - Objecte de tipus PCA amb tota la informació en el
1941             %         subespai de les components principals de l’objecte.
1942             %
1943 
1944             %comprobem si les dades son correctes
1945             z=whos('x');
1946             if(not(strcmp( z.class , 'DATA')))
1947                 %si ens passen algo que no es del tipus DATA Error
1948                 error('PCA\project:waiting for DATA');
1949             end
1950             
1951             if(isempty(obj.P)||isempty(obj.Landa)||isempty(obj.mea)||(isempty(obj.T) && obj.getBatchCount>0))
1952                 %si no hem calculat les dades del nostre model ho
1953                 %fem ara
1954                 obj.pca();
1955             end
1956             
1957             nou=PCA(x);%creem un nou PCA
1958             
1959             %li fixem la desviacio estandard i la mitjana del
1960             %nostre model
1961             nou.mea=obj.mea;
1962             nou.sta=obj.sta;
1963             nou.conv=obj.conv;
1964             nou.metode=obj.metode;
1965             nou.metodee=obj.metodee;
1966             nou.treuFM=obj.treuFM;
1967             nou.ContMetode=obj.ContMetode;
1968             
1969             %Li fixem els limits
1970             
1971             %Fem servir els getxxxx per asegurar que els inicialitzarem
1972             %amb algun valor
1973             
1974             nou.LimT2=obj.getT2Limit;%Limit de T^2
1975             nou.LimQ=obj.getQLimit;%Limit de Q
1976             nou.CLimQstd=obj.getQContributionLimitStd;%Q - Desviació tipica
1977             nou.CLimQmea=obj.getQContributionLimitMean;%Q - Mitjana
1978             nou.CLimT2std=obj.getT2ContributionLimitStd;%T2 - Desviació tipica
1979             nou.CLimT2mea=obj.getT2ContributionLimitMean;%T2 - Mitjana
1980             
1981             %L'estandaritzem
1982             nou.estandaritz2();
1983             
1984             %Fem que no sigui un model
1985             nou.model=0;%no es un model
1986             
1987             nou.structura=obj.structura;
1988             if(obj.metode==5)
1989                 nou.Z=nou.Z(:,nou.structura.sensors{nou.structura.n_loops});
1990                 nou.T=nou.Z*obj.P;
1991                 nou.P=obj.P;
1992                 nou.Landa=obj.Landa;
1993                 nou.Landai=obj.Landai;
1994                 nou.Num=obj.Num;
1995             else
1996                 nou.T=nou.Z*obj.P;
1997                 nou.P=obj.P;
1998                 nou.Landa=obj.Landa;
1999                 nou.Landai=obj.Landai;
2000                 nou.Num=obj.Num;
2001             end
2002         end
2003 
2004 %-------------------------------------------------------------------------%
2005 %% ------------------------ PLOTS & VISUALITZADORS -----------------------
2006 %-------------------------------------------------------------------------%
2007 
2008         %grafic contribucions al limit de T2
2009         function plotT2Contribution(obj,mostrar)
2010             % Metode que fa un plot de les contribucións de T^2. Es pot
2011             % mostrar 1 batch o un conjunt de batch.
2012             % Exemples:
2013             %  1, [1 2 3 4], 1:5, : ...
2014             %Parametres d'entrada:
2015             %
2016             %   mostrar - el numero de batch o el grup de batch que volem
2017             %             mostrar en el grafic
2018             %
2019             %Parametres de sortida:
2020             %
2021             %   No en te
2022             %
2023             if nargin == 1
2024                 error('PCA\plotT2Contribution: we need another parameter!')
2025             end
2026             aux=obj.getT2Contribution();
2027             aux=aux(mostrar,:)';
2028             
2029             bar(aux,'HitTest','off');
2030          
2031             %mostrem el limits de contribucio del proces
2032             obj.plotLimCT2('k');
2033             
2034             if(obj.conv == 0)
2035                 
2036                 hold on;
2037                 % Crea las lineas de las divisiones de las fases.
2038                 z=obj.DATA.getStagesDurations();
2039                 a=0;
2040                 i=1;
2041 
2042                 %Trobem el maxim i minim que ocuperan els plots
2043                 maxim = max(max(max(aux)),max(obj.getT2ContributionLimitMean+obj.getT2ContributionLimitStd*3));
2044                 minim = min(min(min(aux)),min(-(obj.getT2ContributionLimitMean+obj.getT2ContributionLimitStd*3))) * obj. ContMetode; %el Cont metode 0 = positius  1 = positius i negatius
2045                 
2046                 vars=obj.DATA.getVariableLabel();
2047                 fases=obj.DATA.getStages();
2048                 for x = 1:length(z)*length(obj.DATA.getVariableLabel)
2049                     a=a+z(i);
2050                     line([a,a],[maxim+0.2,minim-0.2],'linestyle',':','color',[0.40,0.40,0.40],'HitTest','off');
2051                     text(a-z(i)/2,minim-0.2,fases(i),'FontSize',8,'LineWidth',0.5);
2052                     if(i==length(z))
2053                         i=0;
2054                         line([a,a],[maxim+0.2,minim-0.2],'linestyle','--','color','k','HitTest','off');
2055                         text(a-sum(z)/2,maxim+0.2,vars(x/length(z)),'FontSize',15,'LineWidth',0.7);
2056                     end
2057                     i=i+1;
2058                 end
2059                 hold off;
2060             end
2061         end
2062         %grafic contribucions al limit de Q
2063         function plotQContribution(obj,mostrar)
2064             % Metode que fa un plot de les contribucións de Q. Es pot
2065             % mostrar 1 batch o un conjunt de batch.
2066             % Exemples:
2067             %  1, [1 2 3 4], 1:5, : ...
2068             %Parametres d'entrada:
2069             %
2070             %   mostrar - el numero de batch o el grup de batch que volem
2071             %             mostrar en el grafic
2072             %
2073             %Parametres de sortida:
2074             %
2075             %   No en te
2076             %
2077             if nargin == 1
2078                 error('PCA\plotQContribution: We need another parameter!')
2079             end
2080             
2081             aux=obj.getQContribution();
2082             aux=aux(mostrar,:)';
2083             bar(aux,'HitTest','off');
2084            
2085                         
2086             %mostrem el limits de contribucio del proces
2087             obj.plotLimCQ('k');
2088             if(obj.conv == 0)
2089                 hold on;
2090                 
2091                 % Crea las lineas de las divisiones de las fases.
2092                 z=obj.DATA.getStagesDurations();
2093                 a=0;
2094                 i=1;
2095 
2096                 %Trobem el maxim i minim que ocuperan els plots
2097                 maxim = max(max(max(aux)),max(obj.getQContributionLimitMean+obj.getQContributionLimitStd*3));
2098                 minim = min(min(min(aux)),min(-(obj.getQContributionLimitMean+obj.getQContributionLimitStd*3))) * obj. ContMetode; %el Cont metode 0 = positius  1 = positius i negatius
2099                 
2100                 vars=obj.DATA.getVariableLabel();
2101                 fases=obj.DATA.getStages();
2102                 for x = 1:length(z)*length(obj.DATA.getVariableLabel)
2103                     a=a+z(i);
2104                     line([a,a],[maxim+0.2,minim-0.2],'linestyle',':','color',[0.40,0.40,0.40],'HitTest','off');
2105                     text(a-z(i)/2,minim-0.2,fases(i),'FontSize',8,'LineWidth',0.5);
2106                     if(i==length(z))
2107                         i=0;
2108                         line([a,a],[maxim+0.2,minim-0.2],'linestyle','--','color','k','HitTest','off');
2109                         text(a-sum(z)/2,maxim+0.2,vars(x/length(z)),'FontSize',15,'LineWidth',0.7);
2110                     end
2111                     i=i+1;
2112                 end
2113                 hold off;
2114             end
2115         end
2116         
2117         function plotT2MeanContribution(obj)
2118             %Aquesta funció dibuixa les mitjes de les contribucioons de T^2
2119             %de cada classe
2120             %
2121             %Parametres d'entrada:
2122             %
2123             %   Aquest metode no te cap parametre d'entrada
2124             %
2125             %Parametres de sortida:
2126             %
2127             %   Aquest metode no te cap parametre de sortida
2128             %
2129             cla = obj.getClass();
2130             num=unique(cla);
2131             col=hsv(length(num));%jenerem els colors
2132             in = 1;
2133             
2134             conts=obj.getT2Contribution();
2135             
2136             for j = num %per cada classe que te elements
2137                 subplot(length(num),1,j)
2138                 hold on;
2139                 title(['Class ' num2str(j)])
2140                 aux =(conts(cla == j,:))';
2141                 mitja = mean( aux , 2);
2142                 estan = std( aux ,0, 2);
2143                 %plot(mitja,'color',col(in,:))
2144                 aux2 = mitja - estan;
2145                 if(obj.getContMetode == 0)
2146                     aux2(aux2 < 0) = 0;
2147                 end
2148                 area(mitja + estan,'FaceColor',col(in,:), 'BaseValue',min(aux2), 'LineStyle','none')
2149                 area(aux2,'FaceColor','W','BaseValue',min(aux2),'LineStyle','none')
2150                 in=in+1;
2151                 
2152                 
2153                 %linies de fases
2154                 % Crea las lineas de las divisiones de las fases.
2155                 z=obj.DATA.getStagesDurations();
2156                 a=0;
2157                 i=1;
2158                 maxim=max(max(mitja + estan)) +0.2;
2159                 minim = min(min(aux2)) -0.2;
2160                 vars=obj.DATA.getVariableLabel();
2161                 fases=obj.DATA.getStages();
2162                 for x = 1:length(z)*length(obj.DATA.getVariableLabel)
2163                     a=a+z(i);
2164                     line([a,a],[maxim,minim],'linestyle',':','color',[0.40,0.40,0.40]);
2165                     aux =a-z(i)/2;
2166                     text(aux,minim,fases(i),'FontSize',8,'LineWidth',0.5);
2167                     if(i==length(z))
2168                         i=0;
2169                         line([a,a],[maxim,minim],'linestyle','--','color','k');
2170                         text(aux - sum(z)*2/3,maxim,vars(x/length(z)),'FontSize',15,'LineWidth',0.7);
2171                     end
2172                     i=i+1;
2173                 end
2174             end
2175         end
2176         
2177         function plotQMeanContribution(obj)
2178             %Aquesta funció dibuixa les mitjes de les contribucioons de Q
2179             %de cada classe
2180             %
2181             %Parametres d'entrada:
2182             %
2183             %   Aquest metode no te cap parametre d'entrada
2184             %
2185             %Parametres de sortida:
2186             %
2187             %   Aquest metode no te cap parametre de sortida
2188             %
2189             
2190             cla = obj.getClass();
2191             num=unique(cla);
2192             col=hsv(length(num));%jenerem els colors
2193             in = 1;
2194             
2195             conts=obj.getQContribution();
2196             
2197             for j = num %per cada classe que te elements
2198                 subplot(length(num),1,j)
2199                 hold on;
2200                 title(['Class ' num2str(j)])
2201                 aux =(conts(cla == j,:))';
2202                 mitja = mean( aux , 2);
2203                 estan = std( aux ,0, 2);
2204                 aux2 = mitja - estan;
2205                 if(obj.getContMetode == 0)
2206                     aux2(aux2 < 0) = 0;
2207                 end
2208                 area(mitja + estan,'FaceColor',col(in,:), 'BaseValue',min(aux2), 'LineStyle','none')
2209                 area(aux2,'FaceColor','W','BaseValue',min(aux2),'LineStyle','none')
2210                 in=in+1;
2211                 
2212                 %linies de fases
2213                 % Crea las lineas de las divisiones de las fases.
2214                 z=obj.DATA.getStagesDurations();
2215                 a=0;
2216                 i=1;
2217                 maxim=max(max(mitja + estan)) +0.2;
2218                 minim = min(min(aux2)) -0.2;
2219                 vars=obj.DATA.getVariableLabel();
2220                 fases=obj.DATA.getStages();
2221                 for x = 1:length(z)*length(obj.DATA.getVariableLabel)
2222                     a=a+z(i);
2223                     line([a,a],[maxim,minim],'linestyle',':','color',[0.40,0.40,0.40]);
2224                     aux =a-z(i)/2;
2225                     text(aux,minim,fases(i),'FontSize',8,'LineWidth',0.5);
2226                     if(i==length(z))
2227                         i=0;
2228                         line([a,a],[maxim,minim],'linestyle','--','color','k');
2229                         text(aux - sum(z)*2/3,maxim,vars(x/length(z)),'FontSize',15,'LineWidth',0.7);
2230                     end
2231                     i=i+1;
2232                 end
2233             end
2234         end
2235         
2236         function handle = plotT2Q(obj,forma,color,aux)
2237             %Crea el grafic estŕndard de control T^2 vs Q.
2238             %
2239             %Parametres d'entrada:
2240             %
2241             %   forma -(opcional) Per indicar la forma dels punts
2242             %   color -(opcional) Per forçar el color dels punts
2243             %   aux -(opcional) 'log' posara els eixos en escala
2244             %                    logaritmica i amb 'no' no borrara els
2245             %                    datatips existents nomes afegira les noves
2246             %                    dades
2247             %
2248             %Parametres de sortida:
2249             %
2250             %   handle - el handle del plot
2251             %
2252             
2253             %recupero les dades i les guardo en local
2254             T22=obj.getT2;
2255             Q=obj.getQ;
2256             classe=obj.getClass; 
2257             dcm_obj = datacursormode(gcf);
2258             
2259             hold on
2260             %tr indicara si bolem colors o ens els passen
2261             tr= 1==1;
2262             if isempty(whos('color')) || isempty(color)
2263                 col=hsv(length(unique(classe)));%jenerem els colors
2264                 tr= 1==0;
2265             end
2266             
2267             if isempty(whos('forma'))
2268                 forma = '.';%pintem punts
2269             end
2270             in =1;
2271             num=unique(classe);
2272             handle=zeros(1,max(num));
2273             for i = num%per cada classe
2274                 if tr %color o no?
2275                     handle(i)=semilogy(T22(classe==i),Q(classe==i),forma,'color',color);
2276                 else
2277                     handle(i)=semilogy(T22(classe==i),Q(classe==i),forma,'color',col(in,:));
2278                     in=in+1;
2279                 end
2280             end
2281             
2282             if exist('aux','var') && strcmp(aux,'no')
2283                 userdata =get(gca,'Userdata');
2284                 noms=obj.getBatchLabel();
2285                 
2286                 userdata.noms = {userdata.noms{:}, noms{:}};
2287                 userdata.punts{1} = [userdata.punts{1}; T22];
2288                 userdata.punts{2} = [userdata.punts{2}; Q];
2289             else
2290                 userdata.punts={T22,Q};
2291                 userdata.noms=obj.getBatchLabel();
2292             end
2293             if nargin ~= 4 %si es 4 no volen limits
2294                 line([obj.getT2Limit obj.getT2Limit],[1 max(Q)],'color','k','HitTest','off') %T2
2295                 line([1 max(T22)],[obj.getQLimit obj.getQLimit],'color','k','HitTest','off') %Q
2296             end
2297             
2298             %posem a logaritmic
2299             if nargin >= 4 && strcmp(aux,'log')
2300                 ax = axis;
2301                 set (gca, 'yscale', 'log')
2302                 set (gca, 'xscale', 'log')
2303                 axis (ax)
2304             end
2305             
2306             %nom dels eixos
2307             xlabel('T2')
2308             ylabel('Q')
2309             
2310             hold off
2311             
2312             set(gca,'userdata',userdata);
2313             set(dcm_obj,'UpdateFcn',@tipmelot)
2314         end
2315                
2316         function plotScores(varargin)
2317             %Grafica els scores que se li passen per parametre.
2318             %depenent de la quantitat d'scores desitjada el gradic
2319             %resultant variarŕ.
2320             %
2321             % 1 score es tealitzara la grafia d'aquest al llarg del temps
2322             % 2 scores es realitzara la grafica d'un contra l'altre
2323             % 3 scores es realitzara la grafica 3D
2324             %
2325             % A cada classe se li assignara un color diferent
2326             
2327             obj = varargin{1};
2328             switch length(varargin)
2329                 case 1
2330                     errordlg('We need parameters!','Error');
2331                     
2332                 case 2
2333                     a=varargin{2};
2334                     ts=obj.getT();
2335                     dcm_obj = datacursormode(gcf);
2336                     
2337                     hold on
2338                     
2339                     clas=obj.DATA.getClass;
2340                     col=hsv(max(clas));%el color dels punts!
2341                     for i=unique(clas)
2342                         index=clas ==i;
2343                         plot(ts(index,a),'.','color',col(i,:));
2344                     end
2345                     userdata.punts={ts(:,a)};
2346                     userdata.noms=obj.getBatchLabel();
2347                     line([0,length(ts)],[sqrt(obj.Landa(a))*3, sqrt(obj.Landa(a))*3],'color','K','HitTest','off')
2348                     line([0,length(ts)],[-sqrt(obj.Landa(a))*3, -sqrt(obj.Landa(a))*3],'color','K','HitTest','off')
2349                     axis equal
2350                     xlabel('Time')
2351                     ylabel(['T(' num2str(a) ') (' num2str(sum(obj.Landa(a))*100/sum(obj.Landa)) '%)'])
2352                     hold off
2353                     
2354                     set(gca,'userdata',userdata);
2355                     set(dcm_obj,'UpdateFcn',@tipme)
2356                     
2357                 case 3
2358                     a=varargin{2};
2359                     b=varargin{3};
2360                     ts=obj.getT();
2361                     dcm_obj = datacursormode(gcf);
2362                     hold on
2363                     
2364                     %per optimitzar guardem les lambdes a una variable!
2365                     lamb = obj.Landai;
2366                     sumlamb = sum(lamb);
2367                     
2368                     [X,Y,Zeta]=ellipsoid(0,0,0,sqrt(lamb(a))*3,sqrt(lamb(b))*3,0);
2369                     surf(X,Y,Zeta,'EdgeColor','none','facecolor',[0.9 0.9 0.9],'HitTest','off');
2370                     
2371                     clas=obj.DATA.getClass;
2372                     col=hsv(max(clas));%el color dels punts!
2373                     for i=unique(clas)
2374                         index=clas ==i;
2375                         plot(ts(index,a),ts(index,b),'.','color',col(i,:));
2376                     end
2377                     
2378                     userdata.punts={ts(:,a),ts(:,b)};
2379                     userdata.noms=obj.getBatchLabel();
2380                     
2381 
2382                     axis equal
2383                     xlabel(['T(' num2str(a) ') (' num2str((lamb(a))*100/sumlamb) '%)'])
2384                     ylabel(['T(' num2str(b) ') (' num2str(sum(lamb(b))*100/sumlamb) '%)'])
2385                     hold off
2386                     
2387                     set(gca,'userdata',userdata);
2388                     set(dcm_obj,'UpdateFcn',@tipme)
2389                     
2390                 case 4
2391                     a=varargin{2};
2392                     b=varargin{3};
2393                     c=varargin{4};
2394                     ts=obj.getT();
2395                     dcm_obj = datacursormode(gcf);
2396                     set(dcm_obj,'SnapToDataVertex','off');
2397             
2398                     
2399                     clas=obj.DATA.getClass;
2400                     col=hsv(max(clas));%el color dels punts!
2401                     for i=unique(clas)
2402                         index=clas ==i;
2403                         plot3(ts(index,a),ts(index,b),ts(index,c),'.','color',col(i,:));
2404                         hold on
2405                     end
2406                     
2407                     %per optimitzar guardem les lambdes a una variable!
2408                     lamb = obj.Landai;
2409                     sumlamb = sum(lamb);
2410                     
2411                     [X,Y,Zeta]=ellipsoid(0,0,0,sqrt(lamb(a))*3,sqrt(lamb(b))*3,sqrt(lamb(c))*3);
2412                     surf(X,Y,Zeta,'EdgeColor','none','facecolor',[0.9 0.9 0.9],'HitTest','off');                    
2413                     
2414                     
2415                     userdata.punts={ts(:,a),ts(:,b),ts(:,c)};
2416                     userdata.noms=obj.getBatchLabel();
2417 
2418                     alpha(0.3);
2419                     axis equal
2420                     xlabel(['T(' num2str(a) ') (' num2str((lamb(a))*100/sumlamb) '%)'])
2421                     ylabel(['T(' num2str(b) ') (' num2str(sum(lamb(b))*100/sumlamb) '%)'])
2422                     zlabel(['T(' num2str(c) ') (' num2str(sum(lamb(c))*100/sumlamb) '%)'])
2423                     
2424                     hold off
2425                     set(gca,'userdata',userdata);
2426                     set(dcm_obj,'UpdateFcn',@tipme)
2427                     
2428                 otherwise
2429                     errordlg('4D is not allowed!','Error');
2430                     
2431             end
2432             
2433         
2434             
2435         end
2436         
2437         function plotVarianceCaptured(obj)
2438             %mostra el % de variança explicat de cada una de les variables,
2439             %en diferents colors es representa quines components principals
2440             %estan explicant quines variables.
2441             
2442             mP=obj.getP();%agafem les P
2443             %comprobem en quin format estan desdoblades les dades
2444             if(obj.conv == 0)
2445                 %Batch-Wise
2446                 mP= mP.^2;
2447                 aux= reshape(mP,obj.DATA.getSampleCount,obj.Num * obj.DATA.getVariableCount);
2448                 v1=reshape((sum(aux,1)'./ obj.DATA.getSampleCount) * 100,obj.DATA.getVariableCount,obj.Num)';
2449                 bar(v1','stacked');
2450                 if ~isempty(obj.DATA.getVariableLabel)
2451                     set(gca,'XTickLabel',obj.DATA.getVariableLabel);
2452                     set(gca,'XTick',1:length(obj.DATA.getVariableLabel));
2453                 end
2454                 inst=cell(1,obj.Num);
2455                 for i=1:obj.Num
2456                    inst{i} = ['% ' num2str(i)] ;
2457                 end
2458                 legend(inst)
2459             else
2460                 %Variable-Wise
2461                 %nomes podem mostrar el % de cada variable
2462                 bar(mP.^2 * 100,'stacked');
2463                 inst=cell(1,obj.Num);
2464                 for i=1:obj.Num
2465                    inst{i} = ['% ' num2str(i)] ;
2466                 end
2467                 legend(inst)
2468             end
2469             xlabel('Variable names')
2470             ylabel('%')
2471         end
2472         
2473         function plotQSignatures(obj)
2474             %Grafic que mostra les signatures de Q, es mostrara una grafica
2475             %on es mostrara per cada lot i instant de temps si falla o no
2476             %falla, les classes es diferenciaran amb colors asignats
2477             %automaticament.
2478             
2479             %preparem les dades
2480             CBgcQ=obj.getQContribution();
2481             CBgcQ= CBgcQ> repmat((obj.getQContributionLimitMean + obj.getQContributionLimitStd *3),[size(CBgcQ,1) 1] ); %pasem a binari
2482             class = obj.getClass;
2483             mcl = max(class);
2484             
2485             hold on
2486             %els colors de les classes
2487             colormap('lines');
2488             color= colormap('lines');
2489             
2490             %Colorets per la llegenda
2491             
2492             leg = cell(mcl,1);
2493             for i = 1 : mcl
2494                 plot(0,0,'.','color',color(i,:),'HitTest','off');
2495                 leg{i} = ['Classe' num2str(i)];
2496             end
2497             
2498             %titols i llegendes
2499             title('Signatures de Q');
2500             xlabel('Time * Variables');
2501             ylabel('Batch Number');
2502             legend(leg);
2503             
2504             %Passem a dibuixar totes les dades
2505             sbq1 = size(CBgcQ,1);%evitem repetir crides
2506             sbq2 = size(CBgcQ,2);%evitem repetir crides
2507             set (gca, 'yscale', 'linear')
2508             set (gca, 'xscale', 'linear')
2509             set (gca,'xLim',[-2  sbq2+10])
2510             set (gca,'yLim',[-2  sbq1+10])
2511             set(gca,'Ytick',1 :floor(sbq1/20)+1: sbq1)
2512             set(gca,'Xtick',1 :floor(sbq2/20)+1: sbq2)
2513             set(gca,'Yticklabel',1 :floor(sbq1/20)+1: sbq1)
2514             set(gca,'Xticklabel',1 :floor(sbq2/20)+1: sbq2)
2515             aux2 = repmat((1:sbq1)',[1 sbq2]);%per optimitzar ho fem fora el bucle
2516             aux1 = CBgcQ .* repmat((1 : sbq2), [sbq1 1] );%per optimitzar ho fem fora el bucle
2517             for i = 1 : mcl
2518                 index = i ==class;
2519                 plot(  aux1 .* repmat(index', [1 sbq2]) , aux2 , '.', 'color', color(i,:),'HitTest','off');
2520             end
2521             %eliminem els ounts erronis
2522             plot(zeros(obj.getBatchCount+1,1),0:obj.getBatchCount,'.W','HitTest','off');
2523             
2524             % Crea las lineas de las divisiones de las fases.
2525             z=obj.DATA.getStagesDurations();
2526             a=0;
2527             i=1;
2528             maxim=max(get(gca,'Ytick')) + 5;
2529             vars=obj.DATA.getVariableLabel();
2530             fases=obj.DATA.getStages();
2531             for x = 1:length(z)*length(obj.DATA.getVariableLabel)
2532                 a=a+z(i);
2533                 line([a,a],[maxim,-0.2],'linestyle',':','color',[0.40,0.40,0.40],'HitTest','off');
2534                 aux =a-z(i)/2;
2535                 text(aux,-0.2,fases(i),'FontSize',8,'LineWidth',0.5);
2536                 if(i==length(z))
2537                     i=0;
2538                     line([a,a],[maxim,-0.2],'linestyle','--','color','k','HitTest','off');
2539                     text(aux - sum(z)*2/3,maxim,vars(x/length(z)),'FontSize',15,'LineWidth',0.7);
2540                 end
2541                 i=i+1;
2542             end
2543             
2544             
2545             hold off;
2546         end
2547         
2548         function plotT2Signatures(obj)
2549             %Grafic que mostra les signatures de T^2, es mostrara una
2550             %grafica on es mostrara per cada lot i instant de temps si
2551             %falla o no falla, les classes es diferenciaran amb colors
2552             %asignats automaticament.
2553             
2554             %Recuperem les contribucions de tots el elements
2555             CBgcQ=obj.getT2Contribution();
2556             
2557             %calculem els que es passen pel criteri de 3 sigma
2558             CBgcQ= CBgcQ> repmat((obj.getT2ContributionLimitMean + obj.getT2ContributionLimitStd * 3 ),[size(CBgcQ,1) 1] ); %pasem a binari
2559             
2560             %classes i el nombre maxim de classes per optimitzar
2561             class = obj.getClass;
2562             mcl = max(class);
2563             
2564             hold on
2565             %els colors de les classes
2566             colormap('lines');
2567             color= colormap('lines');
2568             
2569             %Colorets per la llegenda
2570             leg = cell(mcl,1);
2571             
2572             %posem 3 punts per fer la llegenda
2573             for i = 1 : mcl
2574                 plot(0,0,'.','color',color(i,:),'HitTest','off');
2575                 leg{i} = ['Classe' num2str(i)];
2576             end
2577 
2578             %titols i llegendes
2579               title('Signatures de T2');
2580               xlabel('Time * Variables');
2581               ylabel('Batch number');
2582               legend(leg);
2583 
2584             %Passem a dibuixar totes les dades
2585             sbq1 = size(CBgcQ,1);%evitem repetir crides
2586             sbq2 = size(CBgcQ,2);%evitem repetir crides
2587             set (gca, 'yscale', 'linear')
2588             set (gca, 'xscale', 'linear')
2589             set (gca,'xLim',[-2  sbq2+10])
2590             set (gca,'yLim',[-2  sbq1+10])          
2591             set(gca,'Ytick',1 :floor(sbq1/20)+1: sbq1)
2592             set(gca,'Xtick',1 :floor(sbq2/20)+1: sbq2)
2593             set(gca,'Yticklabel',1 :floor(sbq1/20)+1: sbq1)
2594             set(gca,'Xticklabel',1 :floor(sbq2/20)+1: sbq2)
2595             
2596             aux2 = repmat((1:sbq1)',[1 sbq2]);%per optimitzar ho fem fora el bucle
2597             aux1 = CBgcQ .* repmat((1 : sbq2), [sbq1 1] );%per optimitzar ho fem fora el bucle
2598             for i = 1 : mcl
2599                 index = i ==class;
2600                 plot(  aux1 .* repmat(index', [1 sbq2]) , aux2 , '.', 'color', color(i,:),'HitTest','off');
2601             end
2602             %eliminem els ounts erronis
2603             plot(zeros(obj.getBatchCount+1,1),0:obj.getBatchCount,'.W','HitTest','off');
2604             
2605             % Crea les linees de divisions de fases.
2606             z=obj.DATA.getStagesDurations();
2607             a=0;
2608             i=1;
2609             maxim=max(get(gca,'Ytick')) + 5;
2610             vars=obj.DATA.getVariableLabel();
2611             fases=obj.DATA.getStages();
2612             for x = 1:length(z)*length(obj.DATA.getVariableLabel)
2613                 a=a+z(i);
2614                 line([a,a],[maxim,-0.2],'linestyle',':','color',[0.40,0.40,0.40],'HitTest','off');
2615                 aux =a-z(i)/2;
2616                 text(aux,-0.2,fases(i),'FontSize',8,'LineWidth',0.5);
2617                 if(i==length(z))
2618                     i=0;
2619                     line([a,a],[maxim,-0.2],'linestyle','--','color','k','HitTest','off');
2620                     text(aux - sum(z)*2/3,maxim,vars(x/length(z)),'FontSize',15,'LineWidth',0.7);
2621                 end
2622                 i=i+1;
2623             end
2624             hold off;
2625         end
2626         
2627         function plotScreePlot(obj)
2628             %Grafica de les Lambdas, amb punt seleccionat per a nombre de
2629             %components principals marcat amb asterisc vermell
2630             hold on;
2631             plot(obj.Landai(obj.Landai~=0));
2632             plot(obj.Num,obj.Landa(obj.Num),'*r');
2633             legend({'Lambda';'Priincipal components number'});
2634             hold off;
2635         end
2636         
2637         function plotMean(obj)
2638             %Crea una grafica on es ostra la mitja de les variables
2639             
2640             hold on
2641             plot(obj.mea,'b')
2642             legend({'Mean'});
2643             
2644             %linies de fases
2645             % Crea las lineas de las divisiones de las fases.
2646             z=obj.DATA.getStagesDurations();
2647             a=0;
2648             i=1;
2649             maxim=max(max(obj.mea)) +0.2;
2650             minim = min(min(obj.mea)) -0.2;
2651             vars=obj.DATA.getVariableLabel();
2652             fases=obj.DATA.getStages();
2653             for x = 1:length(z)*length(obj.DATA.getVariableLabel)
2654                 a=a+z(i);
2655                 line([a,a],[maxim,minim],'linestyle',':','color',[0.40,0.40,0.40]);
2656                 aux =a-z(i)/2;
2657                 text(aux,minim,fases(i),'FontSize',8,'LineWidth',0.5);
2658                 if(i==length(z))
2659                     i=0;
2660                     line([a,a],[maxim,minim],'linestyle','--','color','k');
2661                     text(aux - sum(z)*2/3,maxim,vars(x/length(z)),'FontSize',15,'LineWidth',0.7);
2662                 end
2663                 i=i+1;
2664             end            
2665             hold off;
2666         end
2667         
2668         function plotStd(obj)
2669             %Crea una grafica on es ostra la desviacio estandard de les
2670             %variables del procčs
2671             
2672             hold on
2673             plot(obj.sta,'b')
2674             legend({'Standard Desviation'});
2675             
2676             %linies de fases
2677             % Crea las lineas de las divisiones de las fases.
2678             z=obj.DATA.getStagesDurations();
2679             a=0;
2680             i=1;
2681             maxim = max(max(obj.sta)) +0.2 ;
2682             minim = min(min(obj.sta)) -0.2;
2683             vars=obj.DATA.getVariableLabel();
2684             fases=obj.DATA.getStages();
2685             for x = 1:length(z)*length(obj.DATA.getVariableLabel)
2686                 a=a+z(i);
2687                 line([a,a],[maxim,minim],'linestyle',':','color',[0.40,0.40,0.40]);
2688                 aux =a-z(i)/2;
2689                 text(aux,minim,fases(i),'FontSize',8,'LineWidth',0.5);
2690                 if(i==length(z))
2691                     i=0;
2692                     line([a,a],[maxim,minim],'linestyle','--','color','k');
2693                     text(aux - sum(z)*2/3,maxim,vars(x/length(z)),'FontSize',15,'LineWidth',0.7);
2694                 end
2695                 i=i+1;
2696             end            
2697             hold off;
2698         end
2699         
2700         function plotP(obj,index)
2701             %Grafica les components Principals indicades en l'index
2702             %
2703             %Parametres d'entrada:
2704             %
2705             %   index - Index valid en matlab indicant els batch a graficar
2706             %
2707             %Parametres de sortida:
2708             %
2709             %   Aquest metode no te cap parametre de sortida
2710             %
2711             hold on
2712 
2713             plot(obj.P(:,index))
2714             mis=cell(1,length(index));
2715             for i = 1:length(index)
2716                mis{i} = ['Principal Component ' num2str(index(i))] ;
2717             end
2718             legend(mis)
2719             %linies de fases
2720             % Crea las lineas de las divisiones de las fases.
2721             z=obj.DATA.getStagesDurations();
2722             a=0;
2723             i=1;
2724             maxim=max(max(obj.P(:,index))) ;
2725             minim = min(min(obj.P(:,index))) ;
2726             vars=obj.DATA.getVariableLabel();
2727             fases=obj.DATA.getStages();
2728             for x = 1:length(z)*length(obj.DATA.getVariableLabel)
2729                 a=a+z(i);
2730                 line([a,a],[maxim,minim],'linestyle',':','color',[0.40,0.40,0.40]);
2731                 aux =a-z(i)/2;
2732                 text(aux,minim,fases(i),'FontSize',8,'LineWidth',0.5);
2733                 if(i==length(z))
2734                     i=0;
2735                     line([a,a],[maxim,minim],'linestyle','--','color','k');
2736                     text(aux - sum(z)*2/3,maxim,vars(x/length(z)),'FontSize',15,'LineWidth',0.7);
2737                 end
2738                 i=i+1;
2739             end            
2740             hold off;
2741         end
2742         
2743         function plotLoadings(varargin)
2744             %Grafica els loadings indicats.
2745             %Depenent del nombre de loadings demanat es realitzarant
2746             % grafics diferents.
2747             % 1 sol loading s'el representara al llarg del temps
2748             % 2 o 3 loadings sels representara un contre l'altre en 2D o 3D
2749             %
2750             %Cada una de les variables es mostrara d'un color diferent
2751             %assignat automaticament, dins una mateixa variable es mostrara
2752             %un degradat de color al llarg del temps.
2753             
2754             obj = varargin{1};
2755             switch length(varargin)
2756                 case 1
2757                     errordlg('we need parameters!','Error');
2758                 case 2
2759                     Ps=obj.getP();
2760                     a = varargin{2};
2761                     
2762                     vars = obj.getVariableCount;
2763                     temps = obj.getSampleCount;
2764                     col=hsv(vars);%el color dels punts!
2765                     hold on
2766                     for i=1:vars
2767                         index = ((i-1) * temps) +1 : i*temps;
2768                         plot(Ps(index,a),'-','color',col(i,:));
2769                     end                                      
2770                     hold off
2771                     
2772                     xlabel('Time')
2773                     ylabel(['PC ' num2str(a) ' (' num2str(sum(obj.Landa(a))*100/size(Ps,1)) '%)'])
2774                     
2775                     noms = obj.DATA.getVariableLabel;
2776                     if ~isempty(noms)
2777                         legend(noms)
2778                     end
2779                 case 3
2780                     Ps=obj.getP();
2781                     a = varargin{2};
2782                     b = varargin{3};
2783                     
2784                     vars = obj.getVariableCount;
2785                     temps = obj.getSampleCount;
2786                     col=degradatcolors(vars, temps);%el color dels punts!
2787                     hold on
2788                     for j=temps:-1:1
2789                         for i=1:vars
2790                             ind =(j + (i-1)*temps);
2791                             plot(Ps(ind,a),Ps(ind,b),'*','color',col(ind,: ));
2792                         end
2793                     end
2794                     
2795                     minimx = min(min(Ps(:,a)));
2796                     minimy = min(min(Ps(:,b)));
2797                     maximx = max(max(Ps(:,a)));
2798                     maximy = max(max(Ps(:,b)));
2799                     line([0,0],[(minimy - abs(minimy/10)), (maximy + maximy/10)],'color','K','linestyle','--');
2800                     line([(minimx - abs(minimx/10)), (maximx + maximx/10)],[0,0],'color','K','linestyle','--');
2801                     
2802                     hold off
2803                     xlabel(['PC ' num2str(a) ' (' num2str(sum(obj.Landa(a))*100/size(Ps,1)) '%)'])
2804                     ylabel(['PC ' num2str(b) ' (' num2str(sum(obj.Landa(b))*100/size(Ps,1)) '%)'])
2805                     
2806                     noms = obj.DATA.getVariableLabel;
2807                     if ~isempty(noms)
2808                         legend(noms)
2809                     end
2810                     
2811                 case 4
2812                     Ps=obj.getP();
2813                     a = varargin{2};
2814                     b = varargin{3};
2815                     c = varargin{4};
2816                                        
2817                     vars = obj.getVariableCount;
2818                     temps = obj.getSampleCount;
2819                     col=degradatcolors(vars, temps);%el color dels punts!
2820                     for j=temps:-1:1
2821                         for i=1:vars
2822                             ind =(j + (i-1)*temps);
2823                             plot3(Ps(ind,a),Ps(ind,b),Ps(ind,c),'*','color',col(ind,:));
2824                             hold on
2825                         end
2826                     end
2827                     
2828                       minimx = min(min(Ps(:,a)));
2829                     minimy = min(min(Ps(:,b)));
2830                     minimz = min(min(Ps(:,c)));
2831                     
2832                     maximx = max(max(Ps(:,a)));
2833                     maximy = max(max(Ps(:,b)));
2834                     maximz = max(max(Ps(:,c)));
2835                     
2836                     
2837                     line([0,0],[(minimy - abs(minimy/10)), (maximy + maximy/10)],[0,0],'color','K','linestyle','--');
2838                     line([(minimx - abs(minimx/10)), (maximx + maximx/10)],[0,0],[0,0],'color','K','linestyle','--');
2839                     line([0,0],[0,0],[(minimz - abs(minimz/10)),(maximz + maximz/10 )],'color','K','linestyle','--');
2840                     
2841                     hold off
2842                     
2843                     xlabel(['PC ' num2str(a) ' (' num2str(obj.Landa(a)*100/size(Ps,1)) '%)'])
2844                     ylabel(['PC ' num2str(b) ' (' num2str(obj.Landa(b)*100/size(Ps,1)) '%)'])
2845                     zlabel(['PC ' num2str(c) ' (' num2str(obj.Landa(c)*100/size(Ps,1)) '%)'])
2846                     
2847                     noms = obj.DATA.getVariableLabel;
2848                     if ~isempty(noms)
2849                         legend(noms)
2850                     end
2851                 otherwise
2852                     errordlg('4D is not allowed!','Error');
2853             end
2854         end
2855         
2856         function plotOutLiers(obj)
2857             %Funció que fa un boxplot per T i Q on es mostraran els
2858             %outliers i en el datatip es posen els corresponents numeros de
2859             %lot i noms del lot.
2860             %
2861             %Parametres d'entrada:
2862             %
2863             %   Aquest metode no te cap parametre d'entrada
2864             %
2865             %Parametres de sortida:
2866             %
2867             %   Aquest metode no te cap parametre de sortida
2868             %
2869             
2870             if(obj.conv == 1)
2871                 error('PCA/plotOutLiers: can not be used in Variable Wise.');
2872             end
2873             
2874             %recuperem Q i T^2 i fem el diagrama de caixa
2875             Qs=obj.getQ;
2876             Ts=obj.getT2();
2877             
2878             %Recuperem tambe les Classes i noms per optimitzar el bucle
2879             cl=obj.getClass;
2880             noms = obj.getBatchLabel();
2881             
2882             %per cada classe busquem els outlies
2883             for i = unique(cl)
2884                 %Fem una nova figura i en recuperem el cursor per editar el
2885                 %datatip
2886                 fig=figure;
2887                 dcm_obj = datacursormode(fig);
2888                 
2889                 %creem un axes i el pasem a boxplot perque el faci a la
2890                 %figura on tenim capturat el ratoli
2891                 axe=axes;
2892                 boxplot(axe,[Ts(cl==i) Qs(cl==i)]);%dibuixem el boxplot de la classe
2893                 
2894                 hold on;
2895                 %posem les dades que bolem mostrar al datatip al userdata
2896                 set(gca,'userdata',{Ts, Qs, noms});
2897                 
2898                 %Posem el titoli etiquetes als eixos
2899                 title(['Class ' num2str(i) ]);
2900                 hold off;
2901                 set(gca,'XTickLabel',{'T^2' 'Q'});
2902                 
2903                 %posem la funció de datatip a una de propia (datatiper localitzada al final d'aquest fitxer)
2904                 set(dcm_obj,'UpdateFcn',@datatiper);
2905 
2906             end
2907             
2908         end
2909 %-------------------------------------------------------------------------%
2910 %% -------------------- Visualització de l'objecte -----------------------
2911 %-------------------------------------------------------------------------%
2912 
2913         %que fer quan fan doble click subre un objecte
2914         function openvar(nom,~)%el parametre comentat es l'objecte actual
2915             %Aquesta es una funció que sobreescriu l'event per defecte de
2916             %doble click sobre un objecte de tipus PCA en el workspace.
2917             %sobreescrivim la funció de visualització per defecte,
2918             %el parametre ignorat és l'objecte actual el nom ens el passen
2919             %en format text. Aqui invocarem una pantalla especifica per
2920             %visualitzar l'objecte.
2921             %
2922             %!!ATENCIO!! -> Aquest metode no hauria de ser invocat per
2923             %l'usuari directament a menys que sapiga molt bé que esta fent!
2924             x=whos('nom');
2925             if strcmp(x.class,'PCA')
2926                 %no puc saber el nom de la variable -> no fem res!
2927             else
2928                 if(evalin('base',['size(' nom ');']) == [1 1])
2929                         Menu_Configura_PCA(nom)
2930                  end
2931             end
2932         end
2933         
2934         
2935         %com es mostra a consola
2936         function disp(obj)
2937             %funció que sobreescriu la visualització de l'objecte per
2938             %consola i en alguns menus desplegables de matlab.
2939             %Mostrarem informació util per l'usuari (tamany de les dades)
2940             %en comptes de la informació per defecte.
2941             %
2942             % Aquesta funció s'invoca automaticament per Matlab quan cal
2943             % l'usuari no necesita invocarla en cap moment.
2944            obj.DATA.disp(1)    
2945            disp(['unique(classes) = ' num2str(unique(obj.getClass))])
2946         end
2947         
2948       function s = saveobj(varargin)
2949           %Sobreescripture del metode Save de matlab perque funcioni
2950           %correctament amb objectes de tipus PCA.
2951           %
2952           % Varargin contindra l'objecte actual
2953           % s - l'estructura que guardarem
2954           
2955           obj = varargin{1};
2956           %retorna l'objecte en format Structura
2957           s.DATA = obj.DATA;
2958           s.estandar = obj.estandar;
2959           s.model = obj.model;
2960           s.Z = obj.Z;
2961           s.P = obj.P;
2962           s.Num = obj.Num;
2963           s.Num_save = obj.Num_save;
2964           s.T = obj.T;
2965           s.Landa = obj.Landa;
2966           s.Landai = obj.Landai;
2967           s.sta = obj.sta;
2968           s.mea = obj.mea;
2969           s.E = obj.E;
2970           s.T2 = obj.T2;
2971           s.LimT2 = obj.LimT2;
2972           s.LimQ = obj.LimQ;
2973           s.metode = obj.metode;
2974           s.metodee = obj.metodee;
2975           s.treuFM = obj.treuFM;
2976           s.conv = obj.conv;
2977           s.analitic = obj.analitic;
2978           s.structura = obj.structura;
2979           s.CLimQstd = obj.CLimQstd;
2980           s.CLimQmea = obj.CLimQmea;
2981           s.CLimT2std = obj.CLimT2std;
2982           s.CLimT2mea = obj.CLimT2mea;
2983           s.ContMetode = obj.ContMetode;
2984       end
2985     end
2986     
2987     methods (Static)
2988         function obj = loadobj(obj)
2989           %Sobreescripture del metode load de matlab perque funcioni
2990           %correctament amb objectes de tipus PCA.
2991           %
2992           % obj -entra com a structura i surt com a objecte PCA
2993             if isstruct(obj)
2994                 % Call default constructor
2995                 newObj = PCA(DATA());
2996                 % Assign property values from struct
2997                 newObj.DATA = obj.DATA;
2998                 newObj.estandar = obj.estandar;
2999                 newObj.model = obj.model;
3000                 newObj.Z = obj.Z;
3001                 newObj.P = obj.P;
3002                 newObj.Num = obj.Num;
3003                 newObj.Num_save = obj.Num_save;
3004                 newObj.T = obj.T;
3005                 newObj.Landa = obj.Landa;
3006                 newObj.Landai = obj.Landai;
3007                 newObj.sta = obj.sta;
3008                 newObj.mea = obj.mea;
3009                 newObj.E = obj.E;
3010                 newObj.T2 = obj.T2;
3011                 newObj.LimT2 = obj.LimT2;
3012                 newObj.LimQ = obj.LimQ;
3013                 newObj.metode = obj.metode;
3014                 newObj.metodee = obj.metodee;
3015                 newObj.treuFM = obj.treuFM;
3016                 newObj.conv = obj.conv;
3017                 newObj.analitic = obj.analitic;
3018                 newObj.structura = obj.structura;
3019                 newObj.CLimQstd = obj.CLimQstd;
3020                 newObj.CLimQmea = obj.CLimQmea;
3021                 newObj.CLimT2std = obj.CLimT2std;
3022                 newObj.CLimT2mea = obj.CLimT2mea;
3023                 newObj.ContMetode = obj.ContMetode;
3024                 obj = newObj;
3025             end
3026         end
3027     end
3028    
3029 %-------------------------------------------------------------------------%
3030 %% --------------------------- METODES PRIVATS ---------------------------
3031 %-------------------------------------------------------------------------%
3032     
3033     methods(Access = private)
3034         % Si es necesita que siguin publics per qualsebol rao, es pot
3035         %canviar "methods(Access = private)" per "methods(Access = public)" o "methods"
3036         %aquests metodes no seran accesibles des de fora de l'objecte,
3037         %aqui posarem tots els metodes que no ens interessa que els
3038         %usuaris utilitzin en qualsebol moment
3039         
3040 %-------------------------------------------------------------------------%
3041 %% -------- METODES PER CALCULAR EL NOMBRE DE COMPONENTS PRINCIPALS ------
3042 %-------------------------------------------------------------------------%
3043 
3044         %metode de Kaiser
3045         function cDKaiser(obj)
3046             %Aplica el criteri de Kaiser per fixar el numero de components
3047             %principals que agafarem. Aquesta funcio es privada
3048             obj.Num = find(obj.Landa >= 1,1,'last');%l'ultim mes gran que 1
3049             
3050             if isempty(obj.Num)
3051                 obj.Num= 1;
3052             end
3053         end
3054         %metode de Graf Scree
3055         function cGrafscree(obj)
3056             %Mostrem el grafic i demanem a l'usuari que ens entri el
3057             %punt on es trova el colze. Aquesta funcio es privada
3058             figure
3059             plot(obj.Landa);
3060             N = str2double(inputdlg('Entra el punt on hi ha el colze:'));
3061             %N=input('Entra el punt on hi ha el colze:');
3062             z=whos('N');
3063             while(~strcmp(z.class,'double'))
3064                 plot(obj.Landa);
3065                 N = str2double(inputdlg('Entra el punt on hi ha el colze:'));
3066                 %N=input('Entra el punt on hi ha el colze:');
3067                 z=whos('N');
3068             end
3069             obj.Num=N;
3070             
3071         end
3072         %metode de la variança explicada
3073         function cVarExp(obj)
3074             %Calcula el nombre de components necessaris perque la
3075             %variança explicada sigui el % entrat per l'usuari. Aquesta
3076             %funcio es privada
3077             N = str2double(inputdlg('Choose % of variance:'));
3078             %N=input('Entra el % de variança:');
3079             z=whos('N');
3080             while(~strcmp(z.class,'double') || (N>100 || N<0))
3081                 %N=input('Entra el % de variança:');
3082                 N = str2double(inputdlg('Choose % of variance:'));
3083                 z=whos('N');
3084             end
3085             
3086             i = find(cumsum(obj.Landa)*100 / sum(obj.Landa)>N,1);
3087             
3088             obj.Num=i;
3089 
3090         end
3091         %metode grafic amb recomanacio de punt (automatic)!
3092         function colzeanalitic(obj)
3093             %necesitem minim 3 variables per aplicar el metode.Busca el
3094             %punt mes proper a l'origen de cordenades (el colze). Aquesta
3095             %funcio es l'automatització del metode Graff Scree i es privada
3096             
3097             i=2;
3098             zmax=0;
3099             
3100             lan = obj.Landa~=0;
3101             lan=obj.Landa(lan);
3102             Land=lan/max(lan);
3103             
3104             
3105             while(i<size(Land,1)-1)
3106                 %calculem la distancia del (0,0) a la recta que formen
3107                 %l'anterior i el seguent a l'actual
3108                 z=dpr(0,0,(i-1)/(size(Land,1)),Land(i-1),(i+1)/(size(Land,1)),Land(i+1));%( px,py , r1x,r1y , r2x,r2y) (primer la x i la y del punt i despres x,y x, y de dos punts de la recta)
3109                 if(zmax<z)
3110                     zmax=z;%encara no hem arrivat al colze
3111                     x=i;
3112                 end
3113                 i=i+1;%avancem l'actual
3114             end
3115             obj.Num=x;
3116         end
3117         
3118 %-------------------------------------------------------------------------%
3119 %% --------------------- METODES PER ESTANDARITZAR -----------------------
3120 %-------------------------------------------------------------------------%
3121         
3122         %estandaritza
3123         function estandaritza(obj)
3124             %estandaritza la mostra. Aquesta funcio es privada
3125             if(obj.estandar~=1)
3126                 
3127                 switch (obj.metodee)
3128                     %cas1 = AUto Scaling
3129                     case 1
3130                         %tan si es una matriu 2D, 3D passada a 2D es
3131                         %fara igual
3132                         %demanem les dades a l'objecte DATA
3133                         data=getRawData(obj);
3134                         %alculem la mitjana i la desviació estandard
3135                         obj.mea=mean(data,1);
3136                         obj.sta=std(data,0,1);
3137 
3138                         %Cas 2 = Grup Scaling
3139                     case 2
3140                         %agafem el nombre de variables
3141                         vars=obj.DATA.getVariableCount();
3142                         if(obj.conv==0)%batch wide
3143                             %demanem les dades a l'objecte DATA
3144                             data=getRawData(obj);
3145                             duration=size(data,2)/vars;%numero de columnes per cada variable
3146                             for i=1:1:vars
3147 %                                 % Seleccionem les columnes que pertanyen a la variable i
3148                                  aux = data(:,duration * (i - 1) + 1:duration * i);
3149 %                                 % Calculem la desviació estŕndard de les dades
3150                                  deviation_i = std(aux(:));
3151 %                                 % Emplenem les corresponents desviacions estŕndard
3152 %                                 obj.sta(duration * (i - 1) + 1:duration * i) = repmat(deviation_i, 1, duration);
3153                                 
3154                                  %optimitzat
3155                                  obj.sta(duration * (i - 1) + 1:duration * i) =  deviation_i;
3156                             end
3157                         else%variable wise
3158                             if(obj.treuFM>=1)
3159                                 %pasem a batch wise
3160                                 obj.conv=0;%fixem a metode de conversio BW
3161                                 data=getRawData(obj);
3162                                 obj.conv=1;%deixem com estava
3163                                 %calculem
3164                                 duration=size(data,2)/vars;%numero de columnes per cada variable
3165                                 for i=1:1:vars
3166                                     % Seleccionem les columnes que pertanyen a la variable i
3167                                     aux = data(:,duration * (i - 1) + 1:duration * i);
3168                                     % Calculem la desviació estŕndard de les dades
3169                                     deviation_i = std(aux(:));
3170                                     % Emplenem les corresponents desviacions estŕndard
3171                                     %obj.sta(duration * (i - 1) + 1:duration * i) = repmat(deviation_i, 1, duration);
3172                                     
3173                                     obj.sta(duration * (i - 1) + 1:duration * i) = deviation_i;
3174                                 end
3175                             else
3176                                 %demanem les dades a l'objecte DATA
3177                                 data=getRawData(obj); 
3178                                 %alculem la mitjana i la desviació estandard
3179                                 %obj.mea=mean(data,1);
3180                                 obj.sta=std(data,0,1);
3181                             end
3182                         end
3183                         %alculem la mitjana
3184                         obj.mea=mean(data,1);
3185                         
3186                         %Cas 3 = Continous Scaling
3187                     case 3
3188                         %agafem el nombre de variables
3189                         vars=obj.DATA.getVariableCount();
3190                         if(obj.conv==0)%batch wide
3191                             %demanem les dades a l'objecte DATA
3192                             data=getRawData(obj);
3193                             duration=size(data,2)/vars;%numero de columnes per cada variable
3194                             for i=1:1:vars
3195                                 % Seleccionem les columnes que pertanyen a la variable i
3196                                 aux = data(:,duration * (i - 1) + 1:duration * i);
3197                                 %Calculem la mitjana i la desviacio tipica
3198                                 mean_i = mean(aux(:));
3199                                 deviation_i = std(aux(:));
3200                                 % Emplenem les mitjanes
3201                                % obj.mea(duration * (i - 1) + 1: duration *i) = repmat(mean_i, 1, duration); %optimitzem el repmat no es necesari
3202                                obj.mea(duration * (i - 1) + 1: duration * i) = mean_i;
3203                                
3204                                 % Emplenem les desviacions
3205                                 %obj.sta(duration * (i - 1) + 1:duration *i) = repmat(deviation_i, 1, duration);%optimitzem el repmat no es necesari
3206                                 obj.sta(duration * (i - 1) + 1:duration * i) = deviation_i;
3207                             end
3208                         else%variable wise
3209                             %pasem a batch wise
3210                             if(obj.treuFM>=1)
3211                                 obj.conv=0;%fixem a metode de conversio BW
3212                                 data=getRawData(obj);
3213                                 obj.conv=1;%deixem com estava
3214                                 %calculem
3215                                 duration=size(data,2)/vars;%numero de columnes per cada variable
3216                                 for i=1:1:vars
3217                                     % Seleccionem les columnes que pertanyen a la variable i
3218                                     aux = data(:,duration * (i - 1) + 1:duration * i);
3219                                     %Calculem la mitjana i la desviacio tipica
3220                                     mean_i = mean(aux(:));
3221                                     deviation_i = std(aux(:));
3222                                     % Emplenem les mitjanes
3223                                     %obj.mea(duration * (i - 1) + 1: duration * i) = repmat(mean_i, 1, duration);
3224                                     % Emplenem les desviacions
3225                                     %obj.sta(duration * (i - 1) + 1:duration * i) = repmat(deviation_i, 1, duration);
3226                                     
3227                                     %optimitzacions
3228                                     obj.mea(duration * (i - 1) + 1: duration * i) = mean_i;
3229                                     obj.sta(duration * (i - 1) + 1:duration * i) = deviation_i;
3230                                 end
3231                             else
3232                                 %demanem les dades a l'objecte DATA
3233                                 data=getRawData(obj);
3234                                 %alculem la mitjana i la desviació estandard
3235                                 obj.mea=mean(data,1);
3236                                 obj.sta=std(data,0,1);
3237                             end
3238                         end
3239                         
3240                         %Cas 4 = Block Scaling
3241                     case 4
3242                         %agafem el nombre de variables
3243                         vars=obj.DATA.getVariableCount();
3244                         if(obj.conv==0)%batch-wise
3245                             %agafem les duracións
3246                             duration = obj.DATA.getSampleCount();
3247                             %Demanem els blocks a l'usuari
3248                             aux = inputdlg('Enter the block: format [1 1 1 2 2 3 3 3] (for each variavle his wheight)');
3249                             block = evalin('base',aux{1});%evaluem per si entren expresions
3250                             %demanem les dades a l'objecte DATA
3251                             data=getRawData(obj);
3252                             %alculem la mitjana i la desviació estandard
3253                             obj.mea=mean(data,1);
3254                             obj.sta=std(data,0,1);
3255                             for i=1:1:length(block)
3256                                 obj.sta(duration * (i - 1) + 1:duration * i) = obj.sta(duration * (i - 1) + 1:duration * i) .* repmat(sqrt(block(i)), 1, duration);
3257                             end
3258                         else%variable wide
3259                             %pasem a batch wide
3260                             if(obj.treuFM>=1)
3261                                 obj.conv=0;%fixem a metode de conversio BW
3262                                 data=getRawData(obj);
3263                                 obj.conv=1;%deixem com estava
3264                                 %calculem
3265                                 duration=size(data,2)/vars;%numero de columnes per cada variable
3266                                 %Demanem els blocks a l'usuari
3267                                 aux = inputdlg('Enter the block: format [1 1 1 2 2 3 3 3] (for each variavle his wheight)');
3268                                 block = evalin('base',aux{1});%evaluem per si entren expresions
3269                                 %alculem la mitjana i la desviació estandard
3270                                 obj.mea=mean(data,1);
3271                                 obj.sta=std(data,0,1);
3272                                 for i=1:1:length(block)
3273                                     obj.sta(duration * (i - 1) + 1:duration * i) = obj.sta(duration * (i - 1) + 1:duration * i) .* repmat(sqrt(block(i)), 1, duration);
3274                                 end
3275                             else
3276                                 %demanem les dades a l'objecte DATA
3277                                 data=getRawData(obj);
3278                                 %alculem la mitjana i la desviació estandard
3279                                 obj.mea=mean(data,1);
3280                                 obj.sta=std(data,0,1);
3281                                 %Demanem els blocks a l'usuari
3282                                 aux = inputdlg('Enter the block: format [1 1 1 2 2 3 3 3] (for each variavle his wheight)');
3283                                 block = evalin('base',aux{1});%evaluem per si entren expresions
3284                                 for j=1:length(block)
3285                                     obj.sta(j)=obj.sta(j)*sqrt(block(j));
3286                                 end
3287                             end
3288                         end
3289                     otherwise
3290                         error('PCA\estandaritza:estandaritzation method not valid')
3291                 end
3292                 
3293                 %calculem la matriu de Z
3294                 obj.Z = (data - repmat(obj.mea, size(data, 1), 1)) ./ repmat(obj.sta, size(data, 1), 1);
3295                 %fixem a estandaritzat
3296                 obj.estandar=1;
3297                 
3298                 if( obj.conv==1 && obj.metodee~=1)%les dades eren VW
3299                     
3300                     duration=size(data,2)/vars;%numero de columnes per cada variable
3301                     %convertim Z de BW a VW
3302                     x=reshape(obj.Z',[duration vars size(data,1)]);
3303                     x=permute(x,[1 3 2]);
3304                     obj.Z=reshape(x,size(x,2)*size(x,1),size(x,3));
3305                 end
3306             end
3307         end
3308         %estandaritz2 - Per quan no es un model
3309         function estandaritz2(obj)
3310             %estandaritza la mostra amb la mitja i std que tinguem
3311             %entrada en aquest moment. Aquesta funcio es privada
3312             if (obj.conv==1 && obj.metodee~=1 && obj.treuFM>=1)
3313                 obj.conv=0;
3314                 data=obj.getRawData();%agafem les dades en BW encara que estiguem trevallant en VW
3315                 obj.conv=1;%Tornem a indicar que estem en
3316                 %VW
3317             else
3318                 data=obj.getRawData();%Obtenim les dades en BW o VW(en el cas de metodee==1)
3319             end
3320             
3321             %calculem la matriu de Z
3322             obj.Z = (data - repmat(obj.mea, size(data, 1), 1)) ./ repmat(obj.sta, size(data, 1), 1);
3323             %fixem a estandaritzat
3324             obj.estandar=1;
3325             
3326             if( obj.conv==1 && obj.metodee~=1 && obj.treuFM>=1)%les dades eren VW
3327                 %convertim Z de BW a VW
3328                 vars=obj.DATA.getVariableCount();
3329                 duration=size(data,2)/vars;
3330                 x=reshape(obj.Z',[duration vars size(data,1)]);
3331                 x=permute(x,[1 3 2]);
3332                 obj.Z=reshape(x,size(x,2)*size(x,1),size(x,3));
3333                 
3334             end
3335             
3336         end
3337         
3338 %-------------------------------------------------------------------------%
3339 %% ------------------------ METODES PER CALCULAR -------------------------
3340 %-------------------------------------------------------------------------%
3341         
3342         %CalculaE
3343         function calculaE(obj)
3344             %calcula la matriu d'Errors. Aquesta funcio es privada
3345             if(isempty(obj.P)||isempty(obj.Z))&& obj.getBatchCount>0
3346                 %si no s'han calculat mai les dades ho fem ara
3347                 obj.pca();
3348             end
3349             %calculem la matriu i la guardem
3350             obj.E= (obj.Z-obj.Z*obj.P*obj.P');
3351         end      
3352         %Metode que escull entre analitic i 3 sigma
3353         function calculaLimQ(obj)
3354             %calculem el limit de Q
3355             if(obj.analitic)
3356                 %analitic = 1 -> analitic
3357                 calculaLimQv2(obj)
3358             else
3359                 %analitic = 0 -> 3 sigma
3360                 calculaLimQv1(obj)
3361             end
3362         end
3363         %Metode que escull entre analitic i 3 sigma
3364         function calculaLimT2(obj)
3365             %Calculem el limit de T^2
3366             if(isempty(obj.T) && obj.getBatchCount>0)
3367                 %necesitem la matriu de T si no la tenim la calculem
3368                 obj.pca();
3369             end
3370 
3371             if(obj.analitic)
3372                 %analitic = 1 -> analitic
3373                 calculaLimT2v2(obj)
3374             else
3375                 %analitic = 0 -> 3 sigma
3376                 calculaLimT2v1(obj)
3377             end
3378         end
3379         %CalculaLimQ per 3 sigma
3380         function calculaLimQv1(obj)
3381             %metode per calcular el limit de Q. Aquesta funcio es privada
3382             if(isempty(obj.E) && obj.getBatchCount>0)
3383                 %si encara no s'ha calculat mai la matriu d'errors la
3384                 %calculem ara
3385                 getE(obj);
3386             end
3387             %fem els calculs i guardem el resultat
3388             Q=((obj.E).^2)*ones(size(obj.E,2),1);
3389             obj.LimQ=mean(Q)+std(Q)*3;
3390         end
3391         %CalculaLimQ analitic
3392         function calculaLimQv2(obj)
3393             %metode per calcular el limit de Q. Aquesta funcio es privada
3394             if(isempty(obj.Landai) && obj.getBatchCount>0)
3395                 %si encara no s'ha calculat mai la matriu d'errors la
3396                 %calculem ara
3397                 obj.pca();
3398             end
3399             %fem els calculs i guardem el resultat
3400             
3401             alpha=0.95; %grau de confiança
3402             ca=norminv(alpha, 0, 1);
3403             ncp=obj.Num;
3404             D=obj.Landai;
3405             theta=zeros(3);
3406             aux = D(ncp+1:length(D));
3407             for i=1:3
3408                 theta(i)=sum(aux.^i);
3409             end
3410             h0=1-2*theta(1)*theta(3)/3/theta(2)^2;
3411             obj.LimQ=theta(1)*(ca*h0*sqrt(2*theta(2))/theta(1)+1+theta(2)*h0*(h0-1)/theta(1)^2)^(1/h0);
3412             
3413         end
3414         %CalculaLimT2 per 3 sigma
3415         function calculaLimT2v1(obj)
3416             %metode per calcular el limit de T^2. Aquesta funcio es privada
3417             %guardem les dades
3418             obj.T2=((obj.T).^2);
3419             obj.T2=((obj.T2)./repmat(obj.Landa',size(obj.T2,1),1))*ones(size(obj.T2,2),1);
3420             
3421             obj.LimT2=mean(obj.T2)+ std(obj.T2)*3;
3422         end
3423         %CalculaLimT2 analitic
3424         function calculaLimT2v2(obj)
3425             %metode per calcular el limit de T2 analiticament. Aquesta
3426             %funcio es privada
3427             if(isempty(obj.Num))
3428                 %si no s'han calculat encara les dades ho fem
3429                 obj.pca();
3430             end
3431             %guardem les dades
3432             alpha=0.95;%es el grau de confiança estre 0 i 1
3433             n=size(obj.Z,1);%es el nombre d'observacions
3434             a=obj.Num;%es el numero de components principals retingudea al model
3435             obj.LimT2=a*(n-1)/(n-a)*finv(alpha,a,n-a);
3436             
3437         end
3438         %CalculaContT2
3439         function x = calculaContT2(obj)
3440             %metode per calcular les contribucions de T2. Aquesta funcio es privada
3441             if(isempty(obj.T) && obj.getBatchCount>0)
3442                 obj.pca();
3443             end
3444             %Retorna les dades.
3445             %T2 mirar componen a component si es pasa -> sum de totes les
3446             %que es passen
3447             aux = (obj.T * diag(1./sqrt(obj.Landa)) * obj.P') .* obj.Z;
3448             
3449             if(obj.ContMetode == 0)
3450                 %no bolen els negatius els posem tots a 0
3451                 x = aux .* (aux > 0) ;
3452             else
3453                 %bolen positius i negatius!!
3454                 x = aux;
3455             end
3456                        
3457             if(isempty(obj.CLimT2mea)||isempty(obj.CLimT2std))
3458                 
3459                 % Emplenem les mitjanes
3460                 obj.CLimT2mea=mean(x);%(duration * (i - 1) + 1: duration * i) = repmat(mean_i, 1, duration);
3461                 % Emplenem les desviacions
3462                 obj.CLimT2std=std(x);%(duration * (i - 1) + 1:duration * i) = repmat(deviation_i, 1, duration);
3463                 
3464             end
3465             
3466             
3467         end
3468         %calculaContQ
3469         function x = calculaContQ(obj)
3470             %Calcula les contribucions a Q i el seu limit. Aquesta funcio
3471             %es privada
3472             if(isempty(obj.E)&& obj.getBatchCount>0)
3473                 calculaE(obj);
3474             end
3475             
3476             %Retorna les dades.
3477             if(obj.ContMetode == 0)
3478                 %no bolen els negatius elevem al ^2
3479                 x = (obj.E).^2;
3480             else
3481                 %no elevem al quadrat hi haura positius i negatius!
3482                 x = obj.E;
3483             end
3484             
3485             if(isempty(obj.CLimQmea)||isempty(obj.CLimQstd))
3486                 % Emplenem les mitjanes
3487                 obj.CLimQmea=mean(x);%Calculem la contribucio a la mitjana
3488                 % Emplenem les desviacions
3489                 obj.CLimQstd=std(x);%Calculem la contribucio a la std
3490                 
3491             end
3492             
3493         end
3494         
3495 %-------------------------------------------------------------------------%
3496 %% ---------------------- VISUALITZADORS PARCIALS -------------------------
3497 %-------------------------------------------------------------------------%
3498         %mira si un objecte no model es bo per la contribució al limit Q
3499         function vect = foraCQ(obj)
3500             %mira si un objecte no model es bo per la contribució al limit
3501             %Q
3502             %Parametres d'entrada:
3503             %
3504             %   confi - Es el nivell de confiança per decidir si un element
3505             %           esta fora o no
3506             %
3507             %Parametres de sortida:
3508             %
3509             %   bool - es la classificació de cada element
3510             %
3511            % if obj.model==0%no es model
3512                 x= (repmat(obj.getQContributionLimitMean-obj.getQContributionLimitStd *3,size(obj.getQContribution,1),1) > obj.getQContribution) + (obj.getQContribution > repmat(obj.getQContributionLimitMean+obj.getQContributionLimitStd *3,size(obj.getQContribution,1),1));%Matriu de booleans amb 0 obs. bones i 0 les dolentes
3513                 z=obj.DATA.getStagesDurations();
3514                 resp=zeros(size(x,1),length(z)*length(obj.DATA.getVariableLabel()));
3515                 k=1;
3516                 for i=1:length(obj.DATA.getVariableLabel())%per cada variable
3517                     for j=1:length(z)
3518                         resp(:,(i-1)*length(z)+j)= sum(x(:,k:k+z(j)-1),2);
3519                         k=k+z(j);
3520                     end
3521                 end
3522                 vect=resp;
3523            % else%es model
3524            %     error('PCA/foraCQ: Es un model!');
3525            % end
3526         end      
3527         %grafic de barres amb contribucions al limit de T2
3528         function plotLimCT2(obj,char)
3529             %grafic de barres amb contribucions al limit de T2
3530             %Parametres d'entrada:
3531             %
3532             %   char - el numero de batch o el grup de batch que volem
3533             %           graficar
3534             %
3535             %Parametres de sortida:
3536             %
3537             %   No en te
3538             %
3539             if(isempty(obj.CLimT2mea)||isempty(obj.CLimT2std))%si no estan calculades les calculem
3540                 calculaContT2(obj);
3541             end
3542             hold on;
3543             plot(obj.CLimT2mea+obj.CLimT2std*3,char,'HitTest','off');
3544             
3545             if(obj.ContMetode == 1)
3546                 %hi haura negatius!
3547                 plot(obj.CLimT2mea-obj.CLimT2std*3,char,'HitTest','off'); 
3548             end
3549             
3550             hold off;
3551         end
3552         %grafic de barres amb contribucions al limit de Q
3553         function plotLimCQ(obj,char)
3554             %grafic de barres amb contribucions al limit de Q
3555             %Parametres d'entrada:
3556             %
3557             %   char - el numero de batch o el grup de batch que volem
3558             %           graficar
3559             %
3560             %Parametres de sortida:
3561             %
3562             %   No en te
3563             %
3564             if(isempty(obj.CLimQmea)||isempty(obj.CLimQstd))%si no estan calculades les calculem
3565                 calculaContQ(obj);
3566             end
3567             hold on;
3568             plot(obj.CLimQmea+obj.CLimQstd*3,char,'HitTest','off');
3569             
3570             if(obj.ContMetode == 1)
3571                 %hi haura negatius!
3572                 plot(obj.CLimQmea-obj.CLimQstd*3,char,'HitTest','off');
3573             end
3574             
3575             hold off;
3576         end  
3577 
3578     end
3579 end
3580 
3581 %outliers tip
3582 function out = datatiper(varargin)
3583 %funció per posar el datatip en la funció plotOutLiers()
3584 %No invocar!
3585 %
3586 % varargin - l'estructura que ens passa matlab en crear l'event
3587 % out - El misatge que es mostrara segons que hagi seleccionat l'usuari
3588 try    
3589 dades=get(gca,'Userdata');
3590     pos=varargin{2}.Position;
3591     a=get(gco,'yData');
3592     pos(2)=a(pos(2) - 7);
3593     nomlots = dades{3};
3594     if pos(1)==1 ||  pos(1)==2
3595         numlot=find(dades{pos(1)} ==  pos(2), 1,'first');
3596         if ~isempty(numlot)
3597             out ={['Batch number:' num2str(numlot)];['Batch name: ' nomlots{numlot}] };
3598         else
3599             out='Not a batch!';
3600         end
3601     else
3602         out='Not a batch!';
3603     end
3604 catch
3605     out='Not a batch!';
3606 end
3607 end
3608 
3609 %Scores tip
3610 function out = tipme(varargin)
3611 %funció per posar el datatip utilitzat al grafic plotScores
3612 %No invocar!
3613 %
3614 % varargin - l'estructura que ens passa matlab en crear l'event
3615 % out - El misatge que es mostrara segons que hagi seleccionat l'usuari
3616     dades=get(gca,'Userdata');
3617     pos=varargin{2}.Position;
3618     switch length(dades.punts)
3619         case 1
3620             numlot=find(dades.punts{1} ==  pos(2),1,'first');
3621         case 2
3622             numlot=find(and(dades.punts{1} ==  pos(1), dades.punts{2} ==  pos(2)),1,'first');
3623         case 3
3624             numlot=find(and(and(dades.punts{1} ==  pos(1), dades.punts{2} ==  pos(2)), dades.punts{3} ==  pos(3)),1,'first');
3625     end
3626         
3627     if ~isempty(numlot)
3628         out ={['Batch number:' num2str(numlot)];['Batch name: ' dades.noms{numlot}] };
3629     else
3630         out='Not a batch!';
3631     end
3632 
3633 end
3634 
3635 %plotT2Q tip
3636 function out = tipmelot(varargin)
3637 %funció per posar el datatip plotT2Q
3638 %No invocar!
3639 %
3640 % varargin - l'estructura que ens passa matlab en crear l'event
3641 % out - El misatge que es mostrara segons que hagi seleccionat l'usuari
3642 try
3643     dades=get(gca,'Userdata');
3644     pos=varargin{2}.Position;
3645     switch length(dades.punts)
3646         case 1
3647             numlot=find(dades.punts{1} ==  pos(2),1,'first');
3648         case 2
3649             numlot=find(and(dades.punts{1} ==  pos(1), dades.punts{2} ==  pos(2)),1,'first');
3650         case 3
3651             numlot=find(and(and(dades.punts{1} ==  pos(1), dades.punts{2} ==  pos(2)), dades.punts{3} ==  pos(3)),1,'first');
3652     end
3653         
3654     if ~isempty(numlot)
3655         out ={['Batch name: ' dades.noms{numlot}] };
3656     else
3657         out='Not a batch!';
3658     end
3659 catch err
3660     out='Not a batch!';
3661 end
3662 end

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