source: ether_eccad/trunk/ECCAD_INSERT/src/Produit.cpp @ 70

#include <stdio.h>
#include <string.h>
#include <dirent.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <iterator>
#include <time.h>
#include <iostream>
#include <cmath>
using namespace std;

#include "Produit.h"

static char tampon [2048];

Produit::Produit()
{
}

Produit::~Produit()
{
}

//Mise ￜ jour d'un produit
void Produit::majProduit()
{
}

//Insertion d'un nouveau produit
void Produit::nvProduit()
{
}

//Fonction de calcul des surfaces de pixels
long double Produit::createAreaVincenty(Point point)
{
//        Point* pBas = new Point(point.lat, point.lon + pas/2);
                Point* pBas = new Point(point.lat+pas/2, point.lon);
//        Point* pHaut = new Point(point.lat+pas, point.lon + pas/2);
                Point* pHaut = new Point(point.lat-pas/2, point.lon);
//        Point* pGauche = new Point(point.lat+pas/2, point.lon);
                Point* pGauche = new Point(point.lat, point.lon-pas/2);
//        Point* pDroit = new Point(point.lat+pas/2, point.lon+pas);
                Point* pDroit = new Point(point.lat , point.lon+pas/2);
//        double distancePhautPbas = distance(pHaut, pBas)/1000;
        double distancePhautPbas = distance(pBas, pHaut)/1000;
        double distancePgauchePdroit = distance(pGauche, pDroit)/1000;

        delete pBas;
        delete pHaut;
        delete pGauche;
        delete pDroit;
        return ( (distancePhautPbas *  distancePgauchePdroit) );

        
}

long double Produit::distance(Point* p1, Point* p2)
{
         ////cout<<"lon p1 "<<p1->lon<<" lat p2 "<<p2->lon<<endl;
        p1->lonRad = p1->lon  * ((2*3.14159265)/360) ;
        p2->lonRad = p2->lon * ((2*3.14159265)/360) ;
        p1->latRad = p1->lat * ((2*3.14159265)/360) ;
        p2->latRad = p2->lat * ((2*3.14159265)/360) ;

        ////cout<<"lonrad p2 "<<p2->lonRad<<" lonrad p1 "<<p1->lonRad<<endl;
        long double L = p2->lonRad - p1->lonRad;
        ////cout<<"L "<<L<<endl;
        long double U1 = atan((1 - f) * tan(p1->latRad));
        long double U2 = atan((1 - f) * tan(p2->latRad));

        long double sinU1 = sin(U1);
        long double cosU1 = cos(U1);

        long double sinU2 = sin(U2);
        long double cosU2 = cos(U2);

        long double sinLambda = 0, cosLambda = 0, sinSigma = 0, cosSigma = 0, sigma = 0, sinAlpha = 0, cosSqAlpha = 0, cos2SigmaM = 0;
        long double lambda = L, lambdaP = 2* 3.14159265;
        long double iterLimit = 20;

        while( fabs(lambda-lambdaP) > 1e-12 && --iterLimit>0 )
        {
                sinLambda = sin(lambda);
                cosLambda = cos(lambda);
                sinSigma = sqrt((cosU2*sinLambda) * (cosU2*sinLambda) + (cosU1*sinU2-sinU1*cosU2*cosLambda) * (cosU1*sinU2-sinU1*cosU2*cosLambda));
                if (sinSigma==0) return 0;  // co-incident points
                cosSigma = sinU1*sinU2 + cosU1*cosU2*cosLambda;
                sigma = atan2(sinSigma, cosSigma);
                sinAlpha = cosU1 * cosU2 * sinLambda / sinSigma;
                cosSqAlpha = 1 - sinAlpha*sinAlpha;
 cos2SigmaM = cosSigma - 2*sinU1*sinU2/cosSqAlpha;
                if (isnan(cos2SigmaM)) cos2SigmaM = 0;  // equatorial line: cosSqAlpha=0 (6)
                long double C = f/16*cosSqAlpha*(4+f*(4-3*cosSqAlpha));
                lambdaP = lambda;
                lambda = L + (1-C) * f * sinAlpha * (sigma + C*sinSigma*(cos2SigmaM+C*cosSigma*(-1+2*cos2SigmaM*cos2SigmaM)));
        }

        if (iterLimit == 0) return NAN;  // formula failed to converge

        long double uSq = cosSqAlpha * (a*a - b*b) / (b*b);
        long double A = 1 + uSq/16384*(4096+uSq*(-768+uSq*(320-175*uSq)));
        long double B = uSq/1024 * (256+uSq*(-128+uSq*(74-47*uSq)));
        long double deltaSigma = B*sinSigma*(cos2SigmaM+B/4*(cosSigma*(-1+2*cos2SigmaM*cos2SigmaM)-B/6*cos2SigmaM*(-3+4*sinSigma*sinSigma)*(-3+4*cos2SigmaM*cos2SigmaM)));
        long double s = b*A*(sigma-deltaSigma);
        ////cout<<"s  "<<s<<endl;
        return s;

        
        
}

long double Produit::distanceHaversine(Point* p1, Point* p2)
{
        
        long double a = pow( sin((p2->lat-p1->lat)/2) ,2)+ cos(p2->lat) * pow( sin((p2->lon-p1->lon)/2) ,2);
        long double c = 2*atan2(sqrt(a), sqrt(1-a));
        return R*c;
}

long double Produit::createAreaHaversine(Point point)
{
//        Point* pBas = new Point(point.lat, point.lon + pas/2);
        Point* pBas = new Point(point.lat+pas/2, point.lon);
//        Point* pHaut = new Point(point.lat+pas, point.lon + pas/2);
        Point* pHaut = new Point(point.lat-pas/2, point.lon);
//        Point* pGauche = new Point(point.lat+pas/2, point.lon);
        Point* pGauche = new Point(point.lat, point.lon-pas/2);
//        Point* pDroit = new Point(point.lat+pas/2, point.lon+pas);
        Point* pDroit = new Point(point.lat , point.lon+pas/2);

//      double distancePhautPbas = distanceHaversine(pHaut, pBas)/1000;
        double distancePhautPbas = distanceHaversine(pBas, pHaut)/1000;
        double distancePgauchePdroit = distanceHaversine(pGauche, pDroit)/1000;
        
        delete pBas; 
        delete pHaut; 
        delete pGauche; 
        delete pDroit; 
        return ( distancePhautPbas *  distancePgauchePdroit );
}



char* Produit::getExtensionFileRead(char* fichier) 
{
        
        string fichierStr = fichier;
        
        string nomFich = SplitFilename(fichier);
        size_t found = (nomFich).find_last_of(".") ;
        
        //if ((nomFich).substr(found+1, nomFich.length() ) != NULL )    
                fichierStr=(nomFich).substr(found+1, nomFich.length());
        //else
                //fichierStr="";
                
                return (char*)fichierStr.c_str();
        /*
        char* fich = fichier;
        while (strchr(fich, '/') != NULL)
        {
                 fich = strchr(fich, '/')+1;
        }       
        if ( strchr(fich, '.') != NULL ) 
        fich = strchr(fich, '.')+1;
        else fich = "";
        
        
        return fich;*/
}




//------------------------------------Fonctions de lecture des donnï¿œes brutes-------------------------------------------//

//Scan d'un repertoire : determiner les sous repertoires et les fichiers

Repertoire Produit::scanRep(Repertoire rep)
{
        struct dirent *item;
        static struct stat stat_item;
        DIR *dirp;
        char *addr;
        //cout<<"-----------------------------------------ScanRep------------------------------------"<<endl;   
        if ((dirp = opendir(rep.chemin)) != NULL)
        {
                strcpy(tampon, rep.chemin);
                strcat(tampon, "/");
                addr= &tampon[strlen(tampon)];

                while ((item=readdir(dirp)) != NULL)
                {
                        strcpy(addr, item->d_name);
                        if (!stat(tampon, &stat_item))
                        {
                                if (S_ISDIR(stat_item.st_mode))
                                {
                                        if (strcmp(item->d_name, ".") && strcmp(item->d_name, ".."))
                                        {
                                                Repertoire child;
                                                child.allouRep(stat_item,item->d_name, tampon, rep.level);
                                                rep.children.push_back(child);
                                        }
                                }
                                else
                                        {
                                                Feuille fich = Feuille(stat_item, item->d_name,tampon, rep.level);
                                                rep.fichier.push_back(fich);
                                        }
                        }
                }
                //cout<<"-----------------------------------------end ScanRep------------------------------------"<<endl;
                
        }
        else
        {
                 //logger->addReadersMessagesErrors("Impossible d'ouvrir le perertoire : "+rep.chemin);
                 cout << " --->   Impossible d'ouvrir le repertoire : " << rep.chemin << endl;  
        }
        
        return(rep);
        
}

//iterer sur toute l'arborescence
void Produit::scanParcour(Repertoire rep)
{
        rep = scanRep(rep);
        parcourRep(rep);
}

//--------------------------------------------------------------------------------------------------------------------//

void Produit::parcourRep(Repertoire rep)
{       
        if (!rep.children.empty())
        {
                list<Repertoire>::iterator it;
                for (it = rep.children.begin(); it != rep.children.end(); it++){
                        scanParcour((*it));
                }
        }
        
        if (!rep.fichier.empty())
        {
                base.readBD(logger);
//              cout << "    traitement des fichiers du repertoire : "<< rep.nom << endl;
                        
                bool verifExt;
                        
                list<Feuille>::iterator itt;
                for (itt = rep.fichier.begin(); itt != rep.fichier.end(); itt++)
                {
//                      cout << ".......... Fichier à traiter:"<<  (*itt).nom <<endl;
                        if(!strcmp("NULL", extension))
                                verifExt=true;
                        else
                                verifExt=!strcmp(getExtensionFileRead((*itt).chemin),extension);
//                      cout << ".......... verifExt="<<verifExt <<endl;
                        if ( ( verifExt && base.fichier.verifDate(ctime(&((*itt).stt.st_ctime)), base.produit.getTuple(NomProduit)->id, (*itt).nom) ) || ( !strcmp("", extension) && base.fichier.verifDate(ctime(&((*itt).stt.st_ctime)), base.produit.getTuple(NomProduit)->id, (*itt).nom) ) )
                        {
                                //cout<<"-----------verifDate------------"<<  base.fichier.verifDate(ctime(&((*itt).stt.st_ctime)), base.produit.getTuple(NomProduit)->id, (*itt).nom) <<(*itt).chemin <<endl;
                                //cout<< !strcmp(strchr((*itt).chemin , '.')+1, extension)<<"//////8888//////////"<<endl;
//                              cout << ".......... Traitement du fichier "<<(*itt).chemin<<"    "<<  (*itt).nom <<endl;
                                //cout << ".......... Traitement du fichier : "<<"    "<<  (*itt).nom <<endl;
                                readFile((*itt));
                                //cout << ".......... fin Traitement du fichier : "<<endl;
                        }
                }
                //cout<< " taille rep="<<rep.fichier.size()<<endl;
        }
                
        if (rep.children.empty() && rep.fichier.empty())
        {
                //logger->addReadersMessagesErrors("Le repertoire : "+rep.chemin+"est vide");
                //printf("--- Le repertoire : %s est vide \n", rep.chemin);
                cout<<"--- Le repertoire : "<<rep.chemin<<" est vide"<<endl;
        }
}

void Produit::deleteProduct(string idProduct)
{
        PGconn* conn = base.connectBD(logger);
        string sql = "delete from grille where id_produit ="+idProduct+";";
        ////cout << sql << endl;
        
        PGresult* res = PQexec(conn, sql.c_str());
        if ( PQresultStatus(res) != PGRES_TUPLES_OK)  
        {
                logger->traitementBaseMessages(" DELETE GRILLE " , res);
                ////cout<<"delete"<<endl;
        }
        
        sql = "delete from fichier where id_produit ="+idProduct+";";
        ////cout << sql << endl;
        
        res = PQexec(conn, sql.c_str());
        if ( PQresultStatus(res) != PGRES_TUPLES_OK)  
        {
                logger->traitementBaseMessages(" DELETE FICHIER " , res);
                ////cout<<"delete fichier"<<endl;
        }
        PQfinish(conn); 
}

bool Produit::chercheFichierRep(Rowfichier fichier, Repertoire rep)
{
        rep = scanRep(rep);
        ////cout<<"repchercheFichierRep  "<<rep.nom<<endl;
        bool trouve = false;
        if (!rep.children.empty())
        {
                ////cout<<"children"<<endl;
                list<Repertoire>::iterator itRep;
                for (itRep = rep.children.begin(); itRep != rep.children.end(); itRep++)
                {
                        Repertoire reper = scanRep((*itRep));
                        trouve = chercheFichierRep(fichier, reper);
                }
        }
        if (trouve) return trouve;
        else
        {
                list<Feuille>::iterator itt;
                ////cout<<"taille "<<rep.fichier.size()<<endl;
                ////cout<<"nom rep "<<rep.chemin<<endl;
                //if (rep.fichier.empty()) return trouve;
                for (itt = rep.fichier.begin(); itt != rep.fichier.end(); itt++)
                {
                        /*if (fichier.idProduit == base.produit.getTuple(NomProduit)->id)
                        {*/
                        ////cout <<(*itt).nom<<"      "<<fichier.name<<endl;
                        if(  ( fichier.idProduit == base.produit.getTuple(NomProduit)->id )  && ( !strcmp((*itt).nom, (fichier.name).c_str()) ) ) 
                        {
                                ////cout <<(*itt).nom<<"   **   "<<fichier.name<<endl;
                                trouve = true;
                                return trouve;
                                break;
                        }
                        //}
                }
        }
        return trouve;
        
}



bool Produit::fichierAbst(Tabfichier tabFichier, Repertoire rep)
{

        //cout << "fonction  fichierAbst " <<rep.nom <<endl;
        bool absent;  
        //cout<<"tabFichier"<<tabFichier.tuples.size()<<endl;
        //cout<<"rep"<<rep.fichier.size()<<endl;
        if ( !tabFichier.tuples.empty() )
        { 
                absent = false;
                rep = scanRep(rep);
                
                list<Rowfichier>::iterator it;
                
                for (it = tabFichier.tuples.begin() ; it != tabFichier.tuples.end(); it++){
                        if ((*it).idProduit == base.produit.getTuple(NomProduit)->id){
                                if(!chercheFichierRep((*it), rep)){
                                        absent = true;
                                        break;
                                }
                        }
                }
        }
        else absent=false;
        
        return absent;
        
}

void Produit::readFile(Feuille f)
{
}

void Produit::verifMinMax(float min, float max)
{
        Base baseVerif;
        baseVerif.readBD(logger);
        
        float minBase = atof(  (baseVerif.parametre.getTuple(NomParametre)->minCalculate).c_str()  );
        float maxBase = atof(  (baseVerif.parametre.getTuple(NomParametre)->maxCalculate).c_str()  );
//      cout<<"minbase="<<minBase<<", min="<<min<<", maxbase="<<maxBase<<", max="<<max <<endl;

        if (min < minBase)
        {
                PGconn* conn = base.connectBD(logger);
                string sql = "update parametre set min_param_calculate ="+ ftoa(min) +" where id_param="+ base.parametre.getTuple(NomParametre)->id +";";
                ////cout<<"sql "<<sql<<endl;
                PGresult* res = PQexec(conn, sql.c_str());
                PQfinish(conn);
                
                /*if ( PQresultStatus(res) != PGRES_TUPLES_OK)  
                {
                        logger->traitementBaseMessages(" UPDATE PARAM MIN " , res);
                }*/
        }
        
        if (max > maxBase)
        {
                PGconn* conn = base.connectBD(logger);
                string sql = "update parametre set max_param_calculate ="+ ftoa(max) +" where id_param="+ base.parametre.getTuple(NomParametre)->id +";";
                ////cout<<"sql "<<sql<<endl;
                ////cout<<"maxBase "<<maxBase<<endl;
                PGresult* res = PQexec(conn, sql.c_str());
                PQfinish(conn);
                
                /*if ( PQresultStatus(res) != PGRES_TUPLES_OK)  
                {
                        logger->traitementBaseMessages(" UPDATE PARAM MAX " , res);
                }*/
        }
}