axlShapeBSpline.cpp

Go to the documentation of this file.

#include "axlShapeBSpline.h"

#include <axlCore/axlShape.h>
#include <axlCore/axlMesh.h>

#include <axlCore/axlPoint.h>

#include <dtkLog/dtkLog.h>
#include <dtkCoreSupport/dtkAbstractDataFactory.h>


class axlShapeBSplinePrivate
{
public :
    QVector<axlShapeBSpline::ControlPoint *> points;
    QVector<axlShapeBSpline::Edge *> edges;
    QVector<axlShapeBSpline::Face *> faces;

    int sample;

    QMap<QPair<double, double>, double> scalar_values;
    QHash<int, QList<int> > connect;
};

axlShapeBSpline::axlShapeBSpline() : axlAbstractData(), d(new axlShapeBSplinePrivate)
{
    d->sample = 40;
}

axlShapeBSpline::~axlShapeBSpline()
{
}


// /**
// * @brief Emit a signal edgesSeleted
// * @param numEdge : the identifier of the Edge selected.
// */
// void axlShapeBSpline::emitEdgeSelected(int numEdge){

//     if(numEdge < 0 || numEdge >= d->edges.size()){
//         emit edgeSelected(-1, 0,0);
//     }else{

//         int previous = 0;
//         for(int i = 0; i < numEdge;i++){
//             previous = d->edges.at(i)->support->numSamples()-1 + previous;
//         }
//         int n = d->edges.at(numEdge)->support->numSamples();
//         emit edgeSelected(numEdge, previous,n);
//     }
// }



bool axlShapeBSpline::registered(void) {
    return dtkAbstractDataFactory::instance()->registerDataType("axlShapeBSpline", createaxlShapeBSpline);
}



QString axlShapeBSpline::identifier(void) const{
    return "axlShapeBSpline";
}


QString axlShapeBSpline::description(void) const{
    QString description;
    description.append(identifier());
    description.append( "has ");
    description.append(QString::number(countControlPoints()));
    description.append("control points;");
    description.append(QString::number(countBoundaryEdges()));
    description.append("boundary edges and ");
    description.append(QString::number(d->faces.size()));
    description.append("faces");

    return description;
}


int axlShapeBSpline::order_u() const{
    if(d->faces.isEmpty())
        return -1;
    else
        return d->faces.first()->support->order_u();
}


int axlShapeBSpline::order_v() const{
    if(d->faces.isEmpty())
        return -1;
    else
        return d->faces.first()->support->order_v();
}


void axlShapeBSpline::createSurfaceFromBSplineDataSet(QList<axlAbstractSurfaceBSpline *> dataSet){

    //We suppose all bspline surfaces of dataSet have same orders.
    int order_u = dataSet.first()->order_u();
    int order_v = dataSet.first()->order_v();
    int nbEdges = 0;
    int nbFaces = dataSet.size();

    QVector< QVector<int> >pe;
    QVector< QVector<int> >pf;
    QVector< QPair<int,int> > npf;

    QList<axlPoint > p;
    for(int i = 0; i < dataSet.size(); i++){
        QPair<int, int> pair = QPair<int,int>(dataSet.at(i)->countControlPoints_u(),dataSet.at(i)->countControlPoints_v() );
        QVector<int> pf0;
        for(int j = 1; j <= dataSet.at(i)->countControlPoints();j++){
            const axlPoint& pointa = dataSet.at(i)->getCoef(j);
            if(!isContained(p, pointa, pf0)){
                p.append(pointa);
            }
        }
        pf.append(pf0);
        npf.append(pair);
    }

    int nbpoints = p.size();
    double *points = new double[3*nbpoints];

    for(int i = 0;i < p.size();i++){
        points[3*i] = p.at(i).x();
        points[3*i+1] = p.at(i).y();
        points[3*i+2] = p.at(i).z();
    }

    this->setSurface( order_u, order_v, nbpoints, nbEdges, nbFaces, points, pe, pf, npf );
}

void axlShapeBSpline::setSurface(int order_u, int order_v,int nbpoints,int nbEdges, int nbFaces, double *points, QVector< QVector<int> > pe, QVector< QVector<int> >pf, QVector< QPair<int,int> > npf ){

    setControlPoints(nbpoints,points);

    for (int i = 0; i < nbEdges; i++) {
        setEdge(i, pe.at(i),order_u);
    }

    for(int j = 0; j < nbFaces; j++) {
        setFace(j, pf.at(j), order_u, order_v, npf.at(j).first, npf.at(j).second);
    }
}

void axlShapeBSpline::setControlPoints(int nbpoints, double *points)
{
    for(int i = 0; i < nbpoints;i++){
        //d->points.append(new ControlPoint(i,points[3*i], points[3*i+1], points[3*i+2]));
        d->points.append(new ControlPoint(i,points[3*i], points[3*i+1], 0));// same plane z = 0;
    }
}

void axlShapeBSpline::setFace(int i, QVector<int> p, int order_u, int order_v, int nu, int nv)
{
    axlAbstractSurfaceBSpline *surf = dynamic_cast<axlAbstractSurfaceBSpline *>(dtkAbstractDataFactory::instance()->create("goSurfaceBSpline"));
    double *points = fillCoordinates(p);
    double *knots_u = knots(nu,order_u);
    double *knots_v = knots(nv,order_v);
    surf->setSurface(nu,nv, order_u, order_v,3,knots_u, knots_v, points, false);
    surf->setNumSamples_u(d->sample);
    surf->setNumSamples_v(d->sample);
    d->faces.append(new Face(i,nu,nv,p,surf));
    updateFaceEdges(i);
}

void axlShapeBSpline::setEdge(int i,QVector<int> p, int order)
{
    axlAbstractCurveBSpline *curv = dynamic_cast<axlAbstractCurveBSpline *>(dtkAbstractDataFactory::instance()->create("goCurveBSpline"));
    double *points = fillCoordinates(p);
    double *knot = knots(p.size(),order);
    curv->setCurve(p.size(),order,3,knot, points, false);//rational=false, it is a bspline curve (non-rational one)
    curv->setNumSamples(d->sample);
    d->edges.append(new Edge(i,p,curv));
    for(int pts =0; pts < p.size(); pts++ ){
        d->points.at(p.at(pts))->addEdge(i);
    }
}

void axlShapeBSpline::setFace(int i, QVector<int> p, axlAbstractSurfaceBSpline *surf)
{
    surf->setNumSamples_u(d->sample);
    surf->setNumSamples_v(d->sample);
    d->faces.append(new Face(i,surf->countControlPoints_u(), surf->countControlPoints_v(),p,surf));
    updateFaceEdges(i);
    for(int pts =0; pts < p.size(); pts++ ){
        d->points.at(p.at(pts))->addFace(i);
    }
}


void axlShapeBSpline::setEdge(int i, QVector<int> p, axlAbstractCurveBSpline *curv)
{
    curv->setNumSamples(d->sample);
    d->edges.append(new Edge(i,p,curv));
    for(int pts =0; pts < p.size(); pts++ ){
        d->points.at(p.at(pts))->addEdge(i);
    }
}

void axlShapeBSpline::removeEdge(int i)
{
    for(int j = 0; j < d->edges.at(i)->controlPointsIndices.size();j++){
        int index = getPoint(d->edges.at(i)->controlPointsIndices.at(j))->edges.indexOf(i);
        getPoint(d->edges.at(i)->controlPointsIndices.at(j))->edges.remove(index);
    }

    delete d->edges.at(i);
    //d->edges.at(i) = NULL;
    d->edges.remove(i);
}


//coefficients relatifs aux points de controle.
axlPoint axlShapeBSpline::getCoef(int index) const
{
    QVector<double> coord = d->points.at(index-1)->coordinates;
    return axlPoint(coord.first(), coord.at(1),coord.last());
}

bool axlShapeBSpline::setCoef(int index, double *newCoordinate)
{
    QVector<bool> interRes;

    d->points.at(index-1)->setCoord(newCoordinate);

    for(int i = 0; i < d->edges.size(); i++){
        if(d->edges.at(i)->containsControlPoint(index-1)){
            int ind = d->edges.at(i)->controlPointsIndices.indexOf(index-1);
            interRes.append(d->edges.at(i)->support->setCoef(ind+1, newCoordinate));
        }
    }

    for(int i = 0; i < d->faces.size(); i++){
        if(d->faces.at(i)->containsControlPoint(index-1)){
            int ind = d->faces.at(i)->controlPointsIndices.indexOf(index-1);
            interRes.append(d->faces.at(i)->support->setCoef(ind+1, newCoordinate));
        }
    }
    return !interRes.contains(false);
}

int axlShapeBSpline::countControlPoints() const
{
    return d->points.size();
}

//double axlShapeBSpline::startParam_u(void)
//{
//    DTK_DEFAULT_IMPLEMENTATION;

//    return 0.;
//}
//double axlShapeBSpline::startParam_v(void)
//{
//    DTK_DEFAULT_IMPLEMENTATION;

//    return 0.;
//}

//double axlShapeBSpline::endParam_u(void)
//{
//    DTK_DEFAULT_IMPLEMENTATION;
//    return 1.;
//}
//double axlShapeBSpline::endParam_v(void)
//{
//    DTK_DEFAULT_IMPLEMENTATION;
//    return 1.;
//}
//int axlShapeBSpline::numSamples_u(void)
//{
//    DTK_DEFAULT_IMPLEMENTATION;

//    return 0;
//}
//int axlShapeBSpline::numSamples_v(void)
//{
//    DTK_DEFAULT_IMPLEMENTATION;

//    return 0;
//}

void axlShapeBSpline::eval(axlPoint *point, double u, double v) {
    DTK_DEFAULT_IMPLEMENTATION;
    DTK_UNUSED(point);
    DTK_UNUSED(u);
    DTK_UNUSED(v);
}

void axlShapeBSpline::normal(axlPoint *normal, double u, double v)
{
    DTK_DEFAULT_IMPLEMENTATION;
    DTK_UNUSED(normal);
    DTK_UNUSED(u);
    DTK_UNUSED(v);
}
double axlShapeBSpline::scalarValue(double u, double v)
{
    return d->scalar_values.value(qMakePair<double, double>(u, v));
}

void axlShapeBSpline::setScalarValue(double u, double v, double value)
{
    d->scalar_values.insert(qMakePair<double, double>(u, v), value);
}

int axlShapeBSpline::stripes(void)
{
    DTK_DEFAULT_IMPLEMENTATION;

    return 0;
}

void axlShapeBSpline::setStripes(int stripes)
{
    DTK_DEFAULT_IMPLEMENTATION;
    DTK_UNUSED(stripes);
}

int axlShapeBSpline::countControlPoints_u(void) const
{
    DTK_DEFAULT_IMPLEMENTATION;
    return 0;
}

int axlShapeBSpline::countControlPoints_v(void) const
{
    DTK_DEFAULT_IMPLEMENTATION;
    return 0;
}

QList<int> axlShapeBSpline::getControlPointConnection(int i)
{
    return d->connect.value(i);
}


bool axlShapeBSpline::connectionsAreDefined(void){
    return !d->connect.isEmpty();
}

double axlShapeBSpline::startParam_u(int i){
    return d->faces.at(i)->support->startParam_u();
}

double axlShapeBSpline::startParam_v(int i){
    return d->faces.at(i)->support->startParam_v();
}

double axlShapeBSpline::endParam_u(int i){
    return d->faces.at(i)->support->endParam_u();
}

double axlShapeBSpline::endParam_v(int i){
    return d->faces.at(i)->support->endParam_v();
}

void axlShapeBSpline::eval(axlPoint *point, double u, double v,int i){
    d->faces.at(i)->support->eval(point, u,v);
    point->setCoordinates(point->x(), point->y(), point->z());
}


bool axlShapeBSpline::hasFaces(void){
    return (d->faces.size()>0);
}


int axlShapeBSpline::countFaces(void){
    return d->faces.size();
}


int axlShapeBSpline::countBoundaryEdges() const{
    return d->edges.size();
}

axlShapeBSpline::Edge *axlShapeBSpline::getEdge(int i){
    return d->edges.at(i);
}

axlShapeBSpline::Face *axlShapeBSpline::getFace(int i){
    return d->faces.at(i);
}

axlShapeBSpline::ControlPoint *axlShapeBSpline::getPoint(int i){
    return d->points.at(i);
}

int axlShapeBSpline::numSamples_u(int i){
    return d->faces.at(i)->support->numSamples_u();
}


int axlShapeBSpline::numSamples_v(int i){
    return d->faces.at(i)->support->numSamples_v();
}


void axlShapeBSpline::setNumSamples_u(int numSamples){
    // axlAbstractSurfaceBSpline::setNumSamples_u(numSamples);

    for(int i = 0;i < d->edges.size();i++){
        d->edges.at(i)->support->setNumSamples(numSamples);
    }

    for(int i = 0;i < d->faces.size();i++){
        d->faces.at(i)->support->setNumSamples_u(numSamples);
    }
}

void axlShapeBSpline::setNumSamples_v(int numSamples) {
    for(int i = 0; i < d->faces.size(); i++){
        d->faces.at(i)->support->setNumSamples_v(numSamples);
    }
}

void axlShapeBSpline::normal(axlPoint *currentNormal ,double paramCourant_u, double paramCourant_v,int indice){
    d->faces.at(indice)->support->normal(currentNormal,paramCourant_u,paramCourant_v);
}


void axlShapeBSpline::updateFaceEdges(int numFace){

    if(!d->faces.at(numFace)->edgesIndices.isEmpty())
        d->faces.at(numFace)->edgesIndices.clear();

    QVector<int>e;
    QVector<int> p = d->faces.at(numFace)->controlPointsIndices;

    for(int ip =0; ip < p.size(); ip++){
        if(d->points.at(p.at(ip))->edges.size() == 1 ){
            if(!e.contains(d->points.at(p.at(ip))->edges.first())){
                e.push_back(d->points.at(p.at(ip))->edges.first());
            }
        }
    }
    d->faces.at(numFace)->edgesIndices = e;

}

// PRIVATE

double *axlShapeBSpline::fillCoordinates(QVector<int> p){
    double *point = new double[3*p.size()];
    int ind = 0;

    for(int i= 0; i < p.size();i++){
        point[3*ind] =  d->points.at(p.at(i))->coordinates.first();
        point[3*ind+1] =  d->points.at(p.at(i))->coordinates.at(1);
        point[3*ind+2] =  d->points.at(p.at(i))->coordinates.last();

        ind++;
    }

    return point;
}


double *axlShapeBSpline::knots(int pointsCount, int order)
{
    double *knots = new double[pointsCount + order];
    int knot_number = 1 ;



    for(int i = 0 ; i < order ; i++ )
        knots[i] = 0.0 ;

    for(int i = order ; i < pointsCount ; i++)
        knots[i] = knot_number++ ;

    for(int i = pointsCount ; i < pointsCount + order ; i++)
        knots[i] = knot_number ;



    //        for(int i = 0 ; i < pointsCount + order ; i++)
    //            knots[i] = i ;


    return knots;
}

bool axlShapeBSpline::isContained(QList<axlPoint > list, axlPoint p, QVector<int>& pf){
    bool res = false;

    for(int i = 0;i <list.size(); i++){
        axlPoint listP = list.at(i);
        if(listP.x() == p.x() && listP.y()==p.y() && listP.z()==p.z()){
            pf.append(i);
            res = true;
        }
    }

    if(!res){
        int s = pf.size();
        pf.append(s);
    }


    return res;
}


void axlShapeBSpline::insert_point(axlPoint *point){
    ControlPoint *control = new ControlPoint(d->points.size(),point->x(),point->y(),point->z());
    d->points.append(control);
}


void axlShapeBSpline::insert_point(double x, double y, double z){
    ControlPoint *control = new ControlPoint(d->points.size(),x,y,z);
    d->points.append(control);
}


void axlShapeBSpline::insert_edge(Edge *edge){
    d->edges.append(edge);
}


void axlShapeBSpline::insert_face(Face *face){
    d->faces.append(face);
}

dtkAbstractData *createaxlShapeBSpline(void){
    return new axlShapeBSpline;
}

// /////////////////////////////////////////////////////////////////
// axlDataDynamic documentation
// /////////////////////////////////////////////////////////////////