Wie machen Sie den folgenden code, der die Bilineare interpolation effizienter?

Ich mir sorgen über das image-processing Leistung die ganze Zeit. Unten sind ein paar offensichtliche Punkte zu Bedenken:

Numerische Präzision:

Ist die erste Sache, springt bei mir mit dem code ist die Verwendung von doubles für Schritt Größe, Farbwerte und Koordinaten. Brauchen Sie wirklich dieses Maß an Genauigkeit für diese Mengen? Wenn nicht, können Sie einige profiling zur überprüfung der Leistungsfähigkeit des Codes bei der Verwendung von fixed-point oder Schwimmer statt.

Beachten Sie, dass dies ist eine hardware-abhängige Frage und die Leistung kann oder kann nicht ein Problem sein, je nachdem, ob oder nicht Ihre hardware implementiert, double, float nur, oder keines von beiden (dann sind beide in software implementiert). Die Diskussionen zu diesem Aspekt gehören auch memory-Ausrichtung, verschmolz memory access, etc. Sicherlich sind diese Themen berühren, die "Principles of Computer Organization," es ist mehr Diskussion über dieses Thema ist hier.

Loop Unrolling:

Haben Sie auch erwogen, manuelle loop unrolling? Dies kann oder kann nicht helfen, da dein compiler kann bereits versuchen, nehmen Vorteil von solchen Optimierungen, ist jedoch mindestens eine überlegung Wert, da Sie einen Doppel-Loop-Schleife über potenziell große array-Größen.

Numerische Entlassungen:

In Ihrem getPixel () - Funktion, die Sie auch berechnen image+((x+(y*sx))*3 für jede RGB-Komponente, und dies scheint sich nicht zu ändern, warum nicht einfach berechnen diese Menge einmal am Anfang Ihrer Funktion?

Vektor-Verarbeitung:

Seine schwer zu denken über die Optimierung solcher code ohne zuerst zu Fragen, ob oder nicht, können Sie die Vorteile von Vektor-Verarbeitung. Sie haben Zugriff auf vektorisierte Anweisungen, sets, z.B., SSE?

Parallele Verarbeitung:

Meisten Systeme haben OpenMP installiert. Wenn dem so ist, sollten Sie überlegen, Restrukturierung Ihres Codes zu nutzen, Ihre-Prozessor multi-core-Fähigkeiten. Dies ist überraschend einfach zu implementieren mit pragma ist, seine sicherlich lohnt sich.

Compiler Flags:

Auch, obwohl Sie nicht erwähnt, dass es direkt, compilation-flags beeinflussen die Leistung von C-code. E. g., wenn Sie gcc verwenden, könnten Sie vergleichen die performance-Unterschiede mit:

gcc -std=c99 -o main main.c

vs.

gcc -std=c99 -O3 -o main main.c 

Multiplikation kann weitgehend reduziert in diesem code.

dx berechnet werden kann, die in der äußeren Schleife, und dort bereiten wir das Einmaleins für weitere Operationen wie RT1=(dx*R2)+(1-dx)*R1 da die Multiplikation(R2,R1,etc), von 1 byte Größe.

Den folgenden code läuft ~10-mal schneller als das original auf meinem Rechner (Mac OS, Mac C++ - compiler mit -O3):

#include <stdio.h>
#include <math.h>
#include <stdlib.h>

inline void fast_getPixel(unsigned char *image, int x, int y, int sx, unsigned char *R, unsigned char *G, unsigned char *B)
{
    //Get the colour at pixel x,y in the image and return it using the provided RGB pointers
    //Requires the image size along the x direction!
    unsigned char *ptr = image+((x+(y*sx))*3);
    *R=ptr[0];
    *G=ptr[1];
    *B=ptr[2];
}

inline void fast_setPixel(unsigned char *image, int x, int y, int sx, unsigned char R, unsigned char G, unsigned char B)
{
    //Set the colour of the pixel at x,y in the image to the specified R,G,B
    //Requires the image size along the x direction!
    unsigned char *ptr = image+((x+(y*sx))*3);
    ptr[0]=R;
    ptr[1]=G;
    ptr[2]=B;
}

void build_dx_table(double* table,double dx)
{
    unsigned len = 0xff;
    table[0] = 0;
    for (unsigned i=1;i<len;i++)
    {
        table[i] = table[i-1]+dx;
    }
}

unsigned char *fast_rescale(unsigned char *src, int src_x, int src_y, int dest_x, int dest_y)
{
    double step_x,step_y;          //Step increase as per instructions above
    unsigned char R1,R2,R3,R4;     //Colours at the four neighbours
    unsigned char G1,G2,G3,G4;
    unsigned char B1,B2,B3,B4;
    double RT1, GT1, BT1;          //Interpolated colours at T1 and T2
    double RT2, GT2, BT2;
    unsigned char R,G,B;           //Final colour at a destination pixel
    unsigned char *dst;            //Destination image - must be allocated here!
    int x,y;               //Coordinates on destination image
    double fx,fy;              //Corresponding coordinates on source image
    double dx,dy;              //Fractional component of source image    coordinates
    double dxtable[0xff];

    dst=(unsigned char *)calloc(dest_x*dest_y*3,sizeof(unsigned char));   //Allocate and clear   destination image
    if (!dst) return(NULL);                           //Unable to allocate image

    step_x=(double)(src_x-1)/(double)(dest_x-1);
    step_y=(double)(src_y-1)/(double)(dest_y-1);

    for (x=0,fx=0;x<dest_x;x++,fx+=step_x)         //Loop over destination image
        dx=fx-(int)fx;
        build_dx_table(dxtable,dx);
        for (y=0,fy=0;y<dest_y;y++,fy+=step_y)
        {
            dy=fy-(int)fy;
            fast_getPixel(src,floor(fx),floor(fy),src_x,&R1,&G1,&B1);    //get N1 colours
            fast_getPixel(src,ceil(fx),floor(fy),src_x,&R2,&G2,&B2); //get N2 colours
            fast_getPixel(src,floor(fx),ceil(fy),src_x,&R3,&G3,&B3); //get N3 colours
            fast_getPixel(src,ceil(fx),ceil(fy),src_x,&R4,&G4,&B4);  //get N4 colours
            //Interpolate to get T1 and T2 colours
            RT1=dxtable[R2-R1]+R1;
            GT1=dxtable[G2-G1]+G1;
            BT1=dxtable[B2-B1]+B1;
            RT2=dxtable[R4-R3]+R3;
            GT2=dxtable[G4-G3]+G3;
            BT2=dxtable[B4-B3]+B3;
            //Obtain final colour by interpolating between T1 and T2
            R=(unsigned char)(dy*(RT2-RT1)+RT1);
            G=(unsigned char)(dy*(GT2-GT1)+GT1);
            B=(unsigned char)(dy*(BT2-BT1)+BT1);
            //Store the final colour
            fast_setPixel(dst,x,y,dest_x,R,G,B);
        }
    return(dst);
}