MAth-Cloud-3.0.0/api.ipsocloud.com/math-plaque/main.cpp

#include <QCoreApplication>
#include <QImage>
#include <QJsonObject>
#include <QJsonArray>
#include <QJsonDocument>

#include <imt/PlaqueBase.h>
#include <imt/PlaqueResult.h>
#include <imt/CPlaqueResult.h>

#include <imt/scale.h>

#include <iostream>
using namespace std;

const CScale *g_pCurrentScale;

// ./math -platform offscreen -image=../storage/media/15/a0fd44eb-8174-4d8b-bc76-690bc6e441b3.jpeg -metric=0.3x0.3 -point1=280x259 -point2=411x255

int main(int argc, char *argv[])
{
    QCoreApplication app(argc, argv);

    QImage image;
    double pixelWidth = 0, pixelHeight = 0;
    QList<Point> points;

    // parse cmd line
    foreach(QString arg, QCoreApplication::arguments()) {
        if(arg.startsWith("-image=")) {
            QString path = arg.replace("-image=", "");
            if(!image.load(path)) {
                return -2;
            }
        }
        else if(arg.startsWith("-metric=")) {
            QStringList metric = arg.replace("-metric=", "").split("x");
            if(metric.size()==2) {
                pixelWidth = metric[0].toDouble();
                pixelHeight = metric[1].toDouble();
            }
            else {
                return -1;
            }
        }
        else if(arg.startsWith("-points=")) {
            QStringList pts = arg.replace("-points=", "").split(";");
            for(int i=0; i<pts.size(); i++) {
                QStringList pt = pts[i].split(",");
                Point p;
                p.x = pt[0].toInt();
                p.y = pt[1].toInt();
                points.append(p);
            }
        }
    }
    if(image.isNull() || pixelWidth==0.0 || pixelWidth==0.0) {
        return -3;
    }

    /*
    foreach (Point p, points) {
        std::cout << p.x << ' ' << p.y << std::endl;
    }
    std::cout << "---" << std::endl;
    foreach (Point p, points) {
        std::cout << p.x << ' ' << p.y << std::endl;
    }
    std::cout << image.width() << "x" << image.height() << std::endl;
    std::cout << pixelWidth << "x" << pixelHeight << std::endl;
    */

    Point lum = points.takeLast();

    /*
    foreach (Point p, points) {
        std::cout << p.x << ' ' << p.y << std::endl;
    }
    */

    g_pCurrentScale = new CScale("DLL scale", pixelWidth, pixelHeight);

    CPlaqueResult result;

    int retour = 2;
    retour = 12;
    CPlaqueBase cplaque;
    retour = cplaque.calculPlaque(&image, lum.x, lum.y, points.size(), points);
    retour = 3;

    QJsonObject data;

    // Remplissage des valeurs dans result
    result.result->code_retour = retour;

    result.result->code_debug1 = cplaque.m_debug1;
    result.result->code_debug2 = cplaque.m_debug2;
    result.result->code_debug3 = cplaque.m_debug3;
    result.result->code_debug4 = cplaque.m_debug4;
    result.result->code_debug5 = cplaque.m_debug5;

    result.result->m_type = cplaque.m_type;
    result.result->m_Etape = cplaque.m_Etape;

    result.result->plaque_max_thickness = cplaque.Max();
    data["plaque_max_thickness"] = cplaque.Max();
    result.result->plaque_mean_thickness = cplaque.Mean();
    data["plaque_mean_thickness"] = cplaque.Mean();
    result.result->plaque_area = cplaque.Surface();
    data["plaque_area"] = cplaque.Surface();
    result.result->plaque_mean_density = cplaque.Density();
    data["plaque_mean_density"] = cplaque.Density();

    result.result->numberOfMeasures = cplaque.m_nMesures;
    data["numberOfMeasures"] = cplaque.m_nMesures;
    result.result->m_nPtLongeantPlaque = cplaque.m_nPtLongeantPlaque;
    data["m_nPtLongeantPlaque"] = cplaque.m_nPtLongeantPlaque;
    //result.result->m_nPtList = cplaque.m_nPtList;

    result.result->m_ptInferieur.x = cplaque.m_ptInferieur.x;
    data["m_ptInferieur.y"] = cplaque.m_ptInferieur.x;
    result.result->m_ptInferieur.y = cplaque.m_ptInferieur.y;
    data["m_ptInferieur.y"] = cplaque.m_ptInferieur.y;
    //result.result->m_dataImg = cplaque.m_wimg.data;

    // Transfert de l'image résultats de l'analyse
    unsigned char *dadd, *dadd2, *amax;
    result.result->m_nbpix = cplaque.m_wimg.nbpix;

    result.result->m_dataImg = new unsigned char[cplaque.m_wimg.nbpix];
    dadd = (unsigned char *) cplaque.m_wimg.data;
    amax = dadd + cplaque.m_wimg.nbpix;
    dadd2 =  result.result->m_dataImg;
    while (dadd < amax)
    {
      *dadd2 = *dadd;
      dadd++;
      dadd2++;
    }

    if ( result.result->m_tPtLongeantPlaque )
    {
      delete[] result.result->m_tPtLongeantPlaque;
    }

    result.result->m_tPtLongeantPlaque = new plaque::Point[ cplaque.m_nPtLongeantPlaque ];
    result.result->m_nPtLongeantPlaque = cplaque.m_nPtLongeantPlaque;

    QJsonObject point;

    QJsonArray m_tPtLongeantPlaque;
    for ( int i = 0; i < cplaque.m_nPtLongeantPlaque; i++ )
    {
      result.result->m_tPtLongeantPlaque[ i ].x = cplaque.m_tPtLongeantPlaque[ i ].x;
      result.result->m_tPtLongeantPlaque[ i ].y = cplaque.m_tPtLongeantPlaque[ i ].y;
      point["x"] = result.result->m_tPtLongeantPlaque[ i ].x;
      point["y"] = result.result->m_tPtLongeantPlaque[ i ].y;
      m_tPtLongeantPlaque.append(point);
    }
    data["longeantPlaque"] = m_tPtLongeantPlaque;

    if ( result.result->m_tbPtsTrouvesFin )
    {
      delete[] result.result->m_tbPtsTrouvesFin;
    }

    result.result->m_tbPtsTrouvesFin = new plaque::Point[ cplaque.m_nVecteursTrouves ];
    result.result->m_nVecteursTrouves = cplaque.m_nVecteursTrouves;

    QJsonArray m_tbPtsTrouvesFin;
    for ( int i = 0; i < cplaque.m_nVecteursTrouves; i++ )
    {
      result.result->m_tbPtsTrouvesFin[ i ].x = cplaque.m_tbPtsTrouvesFin[ i ].x;
      result.result->m_tbPtsTrouvesFin[ i ].y = cplaque.m_tbPtsTrouvesFin[ i ].y;
      point["x"] = result.result->m_tbPtsTrouvesFin[ i ].x;
      point["y"] = result.result->m_tbPtsTrouvesFin[ i ].y;
      m_tbPtsTrouvesFin.append(point);
    }
    data["ptsTrouvesFin"] = m_tbPtsTrouvesFin;

    QString json = QJsonDocument(data).toJson(QJsonDocument::Compact);
    std::cout << json.toStdString() << std::endl;

    /*if(status) {
        QJsonObject data;
        data["nearWall"] = ceim.m_bNearWall;
        data["imt_max"] = result2.imt_max;
        data["imt_mean"] = result2.imt_mean;
        data["imt_stddev"] = result2.imt_standardDeviation;
        data["intima_mean"] = result2.intima_mean;
        data["media_mean"] = result2.media_mean;
        data["qualityIndex"] = result2.qualityIndex;
        data["distance"] = result2.distance;
        data["numberOfPoints"] = result2.numberOfPoints;
        QJsonArray vect_intima;
        QJsonArray vect_media;
        QJsonArray vect_adventitia;
        QJsonObject point;
        for (int i=0; i<result2.numberOfPoints; i++) {
            if(result2.vect_intima[i].x>0) {
                point["x"] = result2.vect_intima[i].x;
                point["y"] = result2.vect_intima[i].y;
                vect_intima.append(point);
            }
            if(result2.vect_media[i].x>0) {
                point["x"] = result2.vect_media[i].x;
                point["y"] = result2.vect_media[i].y;
                vect_media.append(point);
            }
            if(result2.vect_adventitia[i].x>0) {
                point["x"] = result2.vect_adventitia[i].x;
                point["y"] = result2.vect_adventitia[i].y;
                vect_adventitia.append(point);
            }
        }
        data["vect_intima"] = vect_intima;
        data["vect_media"] = vect_media;
        data["vect_adventitia"] = vect_adventitia;

        QString json = QJsonDocument(data).toJson(QJsonDocument::Compact);
        std::cout << json.toStdString() << std::endl;
    }*/

    return 0;
}