Bitmap.cpp

Go to the documentation of this file.

/***************************** License **********************************

 Copyright (C) 2008 by Communicative Machines
 http://www.cmlabs.com   All rights reserved.

 This library is free software; you can redistribute it and/or
 modify it under the terms of the GNU Lesser General Public
 License as published by the Free Software Foundation; either
 version 2.1 of the License, or (at your option) any later version.

 This library is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 Lesser General Public License for more details.

 You should have received a copy of the GNU Lesser General Public
 License along with this library; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

************************************************************************/
// Bitmap.cpp: implementation of the Bitmap class.
//
//////////////////////////////////////////////////////////////////////

#include "Bitmap.h"
//#include "BitmapUpdate.h"

#ifdef WIN32
        #include "win32/Bitmap_Win32.cpp"
#else
        #include "linux/Bitmap_Linux.cpp"
#endif

namespace cmlabs {

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

Bitmap::Bitmap() : DataSample("Bitmap") {
        init(0, 0);
}

Bitmap::Bitmap(const JString& filename) : DataSample("Bitmap") {
        init(0, 0);
        if (!this->readFromFile(filename)) {
                printf("Error initialising Bitmap from file '%s'...\n", (char*) filename);
        }
}

Bitmap::Bitmap(int w, int h) : DataSample("Bitmap") {
        init(w, h);
}

Bitmap::Bitmap(char* imgData, int w, int h, bool takeData) : DataSample("Bitmap") {
        if (takeData) {
                width = w;
                height = h;
                size = w * h * 4;
                data = imgData;
                setMaxUpdates(0);
                setBitmapUpdated();
        }
        else {
                init(w, h);
                memcpy(data, imgData, size);
        }
}

Object* Bitmap::clone() const {
        Bitmap* bm = new Bitmap(data, width, height);
        bm->name = name;
        bm->id = id;
        bm->type = type;
        bm->width = width;
        bm->height = height;
        bm->timestamp = timestamp;
        bm->params.removeAll();
        bm->params.copyAll(params);
        bm->setDuration(duration);
        return (Object*) bm;
}

Bitmap::~Bitmap() {
        reset();
}

Bitmap::Bitmap(BitmapUpdate* update) {
        if (update == NULL) {
                init(0, 0);
                return;
        }

        char* updateData = update->getDataLink();
        long updateSize = update->getDataSize();

//      int width = update->getParam("Width").toInt();
//      int height = update->getParam("Height").toInt();
        int width = update->width;
        int height = update->height;

        if ((width <= 0) || (height <= 0) ) {
                init(0, 0);
                return;
        }

        if (!update->getUpdateType().equalsIgnoreCase("Full")) {
                init(width, height);
                this->fillBox(0, 0, width, height, Color(0,0,0));
                updateBitmap(update, false);
        }
        else
                updateBitmap(update, true);
}

bool Bitmap::init(int w, int h) {
        width = w;
        height = h;
        size = w * h * 4;
        data = NULL;
        if (w > 0) {
                data = new char[size];
        }

        setMaxUpdates(0);
        setBitmapUpdated();

        return true;
}





int Bitmap::getMaxUpdates() {
        return params.get("MaxUpdates").toInt();
}

bool Bitmap::setMaxUpdates(int max) {
        params.put("MaxUpdates", JString(max));
        if (aux != NULL) {
                ObjectCollection* dict = (ObjectCollection*) aux;
                if (dict->getCount() > max) {
                        dict->removeAll();
                }
        }
        return true;
}

bool Bitmap::addBitmapUpdateRegion(const Box& updateBox) {
        if (hasBitmapBeenTotallyChanged())
                return true;

        return addBitmapUpdateRegion((Box*) updateBox.clone());
}

bool Bitmap::addBitmapUpdateRegion(Box* box) {
        if (hasBitmapBeenTotallyChanged()) {
                delete(box);
                return true;
        }
        if (aux == NULL)
                aux = new ObjectCollection();
        ObjectCollection* dict = (ObjectCollection*) aux;
        if (dict->getCount() >= getMaxUpdates()) {
                dict->removeAll();
                delete(box);
                return true;
        }

        double x, y;
        if ( (x = box->getLeftX()) < 0) {
                box->grow(x, 0);
                box->move(-1*x, 0);
        }
        if ( (y = box->getUpperY()) < 0) {
                box->grow(0, y);
                box->move(0, -1*y);
        }

        Box* b;
        for (int n=0; n<dict->getCount(); n++) {
                if ( ( (b = (Box*)dict->get(n)) != NULL) && (b->percentOverlap(*box) > 0) ) {
                        b->growToBoundingBox(*box);
                        delete(box);
                        return true;
                }
        }
        return dict->add(box);
}


bool Bitmap::resetBitmapUpdates() {
        if (aux != NULL)
                delete(aux);
        aux = NULL;
        return true;
}

bool Bitmap::setBitmapUpdated() {
        if (aux == NULL)
                aux = new ObjectDictionary();
        return true;
}

bool Bitmap::hasBitmapBeenUpdated() {
        return (aux != NULL);
}

bool Bitmap::hasBitmapBeenTotallyChanged() {
        return ((aux != NULL) && ( ((ObjectDictionary*)aux)->getCount() == 0));
}




bool Bitmap::reset() {
        if (aux != NULL)
                delete(aux);
        aux = NULL;
        delete [] data;
        data = NULL;
        return true;
}

Bitmap* Bitmap::getCopy(const Box& box) {
        Bitmap* bitmap;
        int x = (int) box.upperLeft.x;
        int y = (int) box.upperLeft.y;
        int w = (int) box.size.w;
        int h = (int) box.size.h;

        if (box.upperLeft.x != (int) box.upperLeft.x)
                w++;
        if (box.upperLeft.y != (int) box.upperLeft.y)
                h++;
        if (box.size.w != (int) box.size.w)
                w++;
        if (box.size.h != (int) box.size.h)
                h++;

        bitmap = new Bitmap(w, h);
        bitmap->drawBitmap(this, x, y, 0, 0, w, h);
        return bitmap;
}


char* Bitmap::getGrayScaleDataCopy(int &len) {
        if (size <= 0)
                return NULL;
        len = width*height;
        char* output = new char[len];
        unsigned int* src = (unsigned int*) data;
        char* dst = output;

        for (int n=0; n<len; n++) {
                *dst++ = GET_GRAY_FROM_RGB(*src);
                src++;
        }
        return output;
}

bool Bitmap::copyGrayScaleData(char* src, int len) {
        if (len < width*height)
                return false;
        unsigned int* dst = (unsigned int*) data;

        for (int n=0; n<len; n++) {
                *dst++ = GET_RGB_FROM_GRAY(*src);
                src++;
        }
        return true;
}

bool Bitmap::updateBitmap(BitmapUpdate* update, bool takeData) {

        if (update == NULL)
                return false;

        int updateWidth = update->width;
        int updateHeight = update->height;
        long updateSize = update->getDataSize();
        char* updateData = update->getDataLink();

        JString updateType = update->getUpdateType();
        if (updateType.length() == 0)
                return false;
        else if (updateType.equalsIgnoreCase("Full")) {
                if (updateSize != (updateWidth * updateHeight * 4))
                        return false;
                reset();
                if (takeData) {
                        width = updateWidth;
                        height = updateHeight;
                        size = updateSize;
                        data = updateData;
                        update->clearDataFields();
                }
                else {
                        if ( (updateWidth != width) || (updateHeight != height) ) {
                                reset();
                                init(updateWidth, updateHeight);
                        }
                        memcpy(data, updateData, size);
                }
        }
        else if (updateType.equalsIgnoreCase("RunLength")) {

                if ( (updateWidth != width) || (updateHeight != height) ) {
                        reset();
                        init(updateWidth, updateHeight);
                }

                unsigned int* src = (unsigned int*) updateData;
                unsigned int* dst = (unsigned int*) data;
                int ctrl;
                int len = 0;
                int totallen = 0;
                int pos = 0;
                int tsize = updateSize/4;
                int n;
                while (pos < tsize) {
                        ctrl = (*src >> 24);
                        len = (*src & 0xFFFFFF);
                        src++;
                        pos++;
                        switch(ctrl) {
                                case DATACTRL:
                                        memcpy(dst, src, len*4);
                                        src += len;
                                        dst += len;
                                        totallen += len;
                                        pos += len;
                                        break;
                                case RLECTRL:
                                        for (n=0; n<len; n++)
                                                *dst++ = src[0];
                                        src++;
                                        // dst += len;
                                        totallen += len;
                                        pos++;
                                        break;
                                default:
                                        printf("Wrong CTRL: %d ", ctrl);
                                        pos++;
                                        break;
                        }
                }
        }
        else if (updateType.equalsIgnoreCase("RL16")) {

                if ( (updateWidth != width) || (updateHeight != height) ) {
                        reset();
                        init(updateWidth, updateHeight);
                }

                unsigned int* src = (unsigned int*) updateData;
                unsigned int* dst = (unsigned int*) data;
                int ctrl;
                int len = 0;
                int totallen = 0;
                int pos = 0;
                int tsize = updateSize/4;
                int n;
                unsigned int i1, i2;
                while (pos < tsize) {
                        ctrl = (*src >> 24);
                        len = (*src & 0xFFFFFF);
                        src++;
                        pos++;
                        switch(ctrl) {
                                case DATACTRL:
                                        for (n=0; n<len; n++) {
                                                *dst++ = GET_FIRSTRGB_FROM_DRGB(*src);
                                                *dst++ = GET_SECONDRGB_FROM_DRGB(*src);
                                                src++;
                                        }
                                //      memcpy(dst, src, len*4);
                                //      src += len;
                                //      dst += len;
                                        pos+=len;
                                        totallen+=len+len;
                                        break;
                                case RLECTRL:
                                        i1 = GET_FIRSTRGB_FROM_DRGB(*src);
                                        i2 = GET_SECONDRGB_FROM_DRGB(*src);
                                        src++;
                                        for (n=0; n<len; n++) {
                                                *dst++ = i1;
                                                *dst++ = i2;
                                        }
                                        totallen+=len+len;
                                        pos++;
                                        break;
                                default:
                                        printf("Wrong CTRL: %d ", ctrl);
                                        pos++;
                                        break;
                        }
                }
        }
        else if (updateType.equalsIgnoreCase("Dif")) {

                if ( (updateWidth != width) || (updateHeight != height) ) {
                        reset();
                        init(updateWidth, updateHeight);
                }

                unsigned int* src = (unsigned int*) updateData;
                unsigned int* dst = (unsigned int*) data;
                int ctrl;
                int len = 0;
                int totallen = 0;
                int pos = 0;
                int tsize = updateSize/4;
                while (pos < tsize) {
                        ctrl = (*src >> 24);
                        len = (*src & 0xFFFFFF);
                        src++;
                        pos++;
                        switch(ctrl) {
                                case DATACTRL:
                                        memcpy(dst, src, len*4);
                                        src += len;
                                        dst += len;
                                        totallen += len;
                                        pos += len;
                                        break;
                                case DIFCTRL:
                                        dst += len;
                                        // dst += len;
                                        totallen += len;
                                        // pos++;
                                        break;
                                default:
                                        printf("Wrong CTRL: %d ", ctrl);
                                        pos++;
                                        break;
                        }
                }
        }
        else if (updateType.equalsIgnoreCase("DifRunLength")) {

                if ( (updateWidth != width) || (updateHeight != height) ) {
                        reset();
                        init(updateWidth, updateHeight);
                }

                unsigned int* src = (unsigned int*) updateData;
                unsigned int* dst = (unsigned int*) data;
                int ctrl;
                int len = 0;
                int totallen = 0;
                int pos = 0;
                int tsize = updateSize/4;
                while (pos < tsize) {
                        ctrl = (*src >> 24);
                        len = (*src & 0xFFFFFF);
                        src++;
                        pos++;
                        int n;
                        switch(ctrl) {
                                case DATACTRL:
                                        memcpy(dst, src, len*4);
                                        src += len;
                                        dst += len;
                                        totallen += len;
                                        pos += len;
                                        break;
                                case RLECTRL:
                                        for (n=0; n<len; n++)
                                                *dst++ = src[0];
                                        src++;
                                        // dst += len;
                                        totallen += len;
                                        pos++;
                                        break;
                                case DIFCTRL:
                                        dst += len;
                                        // dst += len;
                                        totallen += len;
                                        // pos++;
                                        break;
                                default:
                                        printf("Wrong CTRL: %d ", ctrl);
                                        pos++;
                                        break;
                        }
                }
        }

        setBitmapUpdated();
        return true;
}




//////////////////////////////////////////////////////////////////////
// Basic Functions
//////////////////////////////////////////////////////////////////////

bool Bitmap::setPixel(int x, int y, int red, int green, int blue, int alpha) {
        if (data == NULL)
                return false;

        if ((y < 0) || (y >= height) || (x < 0) || (x >= width))
                return false;

        unsigned int* dst = ((unsigned int*) data) + y*width + x;
        *dst = red + (green << 8) + (blue << 16) + (alpha << 24);
        return true;
}

bool Bitmap::setPixel(long pos, int red, int green, int blue, int alpha) {
        if (data == NULL)
                return false;
        if (pos >= size)
                return false;
        *(data+pos) = red;
        *(data+pos+1) = green;
        *(data+pos+2) = blue;
        *(data+pos+3) = alpha;
        setBitmapUpdated();
        return true;
}

bool Bitmap::setPixelXOR(int x, int y, int red, int green, int blue, int alpha) {
        if (data == NULL)
                return false;

        if ((y < 0) || (y >= height) || (x < 0) || (x >= width))
                return false;

        unsigned int* dst = ((unsigned int*) data) + y*width + x;
        *dst |= red + (green << 8) + (blue << 16) + (alpha << 24);
        return true;
}

bool Bitmap::setPixelXOR(long pos, int red, int green, int blue, int alpha) {
        if (data == NULL)
                return false;
        if (pos >= size)
                return false;
        *(data+pos) |= red;
        *(data+pos+1) |= green;
        *(data+pos+2) |= blue;
        *(data+pos+3) |= alpha;
        setBitmapUpdated();
        return true;
}

Pixel Bitmap::getPixel(int x, int y) {
        Pixel p;
        p.x = x;
        p.y = y;
        p.value = NULL;
        getPixel(&p);
        return p;
}

bool Bitmap::getPixel(Pixel* pixel) {
        if (pixel == NULL)
                return false;
        if ( (pixel->x < 0) || (pixel->y < 0) || (pixel->x >= width) || (pixel->y >= height) )
                return false;
        pixel->value = (unsigned int*)(data + (pixel->y*width*4) + (pixel->x * 4));
        return true;
}


long Bitmap::getPos(int x, int y) {
        if ( (x < 0) || (y < 0) || (x >= width) || (y >= height) )
                return false;
        return (y * width*4) + (x * 4);
}

double Bitmap::getDPos(double x, double y) {
        if ( (x < 0) || (y < 0) || (x >= width) || (y >= height) )
                return false;
        return (y * width*4) + (x * 4);
}

Pixel Bitmap::getXY(long pos) {
        Pixel p;
        ldiv_t d;
        d = ldiv(pos, width);
        p.y = d.quot;
        p.x = d.rem;
        p.value = (unsigned int*)(data + (p.y*width*4) + (p.x * 4));
        return p;
}







//////////////////////////////////////////////////////////////////////
// Bitmap Functions
//////////////////////////////////////////////////////////////////////

bool Bitmap::eraseBitmap() {
        return eraseBitmap(255, 255, 255);
}

bool Bitmap::eraseBitmap(int r, int g, int b, int a) {
        long n;

        BYTE c[4];
        // if (eraseLine == NULL)
        int byteWidth = width*4;
        char* eraseLine = new char[byteWidth];
        c[0] = (BYTE) r;
        c[1] = (BYTE) g;
        c[2] = (BYTE) b;
        c[3] = (BYTE) a;

/*      if (r == 255)
                c[0] = (BYTE) 254;
        if (g == 255)
                c[1] = (BYTE) 254;
        if (b == 255)
                c[2] = (BYTE) 254;*/

        for (n=0; n<byteWidth; n+=4)
                memcpy(eraseLine+n, c, 4);

//      for (n=0; n < size; n+=ymax)
        for (n=0; n < size; n+=(byteWidth))
                memcpy(data+n, eraseLine, byteWidth);

        delete [] eraseLine;
        setBitmapUpdated();
        return true;
}

bool Bitmap::eraseBitmap(const Color& color) {
        return eraseBitmap(color.r, color.g, color.b);
}

bool Bitmap::replaceColor(const Color& oldColor, const Color& newColor) {
        if (data == NULL)
                return false;

        unsigned int oldcolval = oldColor.r + (oldColor.g << 8) + (oldColor.b << 16);
        unsigned int newcolval = newColor.r + (newColor.g << 8) + (newColor.b << 16);

        unsigned int* src = (unsigned int*) data;
        int len = width * height;
        for (int n=0; n<len; n++) {
                if ((*src & 0xffffff) == oldcolval)
                        *src++ = (*src & 0xff000000) + newcolval;
                else
                        src++;
        }
        return true;
}


bool Bitmap::fillBox(const Box& box, const Color& color) {
        return fillBox((int) box.getLeftX(), (int) box.getUpperY(), (int) box.getWidth(), (int) box.getHeight(), color);
}

bool Bitmap::fillBox(int x, int y, int w, int h, const Color& color) {
        
        int byteWidth = width*4;

        if (x < 0) {
                w += x;
                x = 0;
        }
        if (y < 0) {
                h += y;
                y = 0;
        }

        if (w + x > width)
                w = width - x;
        if (h + y > height)
                h = height - y;
        if ( (w <= 0) || (h <= 0) )
                return false;

        int n;
        int copybytes = w * 4;
        char* src = new char[copybytes];

        for (n=0; n < copybytes; n+=4) {
                src[n] = color.r;
                src[n+1] = color.g;
                src[n+2] = color.b;
                src[n+3] = 0;
        }

        char* dst = data + (y*byteWidth + x*4);
        for (n=0; n < h; n++) {
                memcpy(dst, src, copybytes);
                dst += byteWidth;
        }
        delete [] src;
        addBitmapUpdateRegion(Box(x, y, w, h));
        return true;
}

Color Bitmap::getPixelColor(int x, int y) {
        Color resColor;
        if ( (x < 0) || (y < 0) || (x >= width) || (y >= height) )
                return Color();
        long pos = getPos(x, y);
        resColor.r = *(unsigned char*)(data + pos);
        resColor.g = *(unsigned char*)(data + pos + 1);
        resColor.b = *(unsigned char*)(data + pos + 2);
        return resColor;
}




bool Bitmap::putTransPixel(int x, int y, const Color& color, double weight) {
        if ( (x < 0) || (y < 0) || (x >= width) || (y >= height) )
                return false;
        unsigned char* ppix = (unsigned char*)data + (y*width*4) + (x*4);
        ppix[0]=(unsigned char)((weight*color.r)+(1-weight)*ppix[0]);
        ppix[1]=(unsigned char)((weight*color.g)+(1-weight)*ppix[1]);
        ppix[2]=(unsigned char)((weight*color.b)+(1-weight)*ppix[2]);
        return true;
}

bool Bitmap::drawLine(const Line& line, const Color& color) {

        int x1 = (int) line.startPoint.x;
        int y1 = (int) line.startPoint.y;
        int x2 = (int) line.endPoint.x;
        int y2 = (int) line.endPoint.y;

        // some useful constants first
        double const dw=x2-x1;
        double const dh=y2-y1;
        double const slx=dh/dw;
        double const sly=dw/dh;

        int extras = 0;
        double alpha;

        // determine wichever raster scanning behaviour to use
        if(fabs(slx)<1.0)
        {
                if (line.lineWidth <= 1)
                        extras = 0;
                else if ((dh != 0) && (dw != 0)) {
                        alpha = atan((double)dw/dh);
                        extras = (int)(line.lineWidth / cos((clPI*0.5) - alpha));
                }

                // x scan
                int tx1=x1;
                int tx2=x2;
                double raster=y1;

                if(x1>x2)
                {
                        tx1=x2;
                        tx2=x1;
                        raster=y2;
                }

                for(int x=tx1;x<=tx2;x++)
                {
                        int const ri=int(raster);

                        double const in_y0=1.0-(raster-ri);
                        double const in_y1=1.0-(ri+1-raster);

                        putTransPixel(x, ri+0 ,color, in_y0);
                        for (int n=0; n<extras; n++)
                                putTransPixel(x, ri+n+1 ,color, 1.0);
                        putTransPixel(x, ri+extras+1 ,color, in_y1);

                        raster+=slx;
                }
        }
        else
        {
                if (line.lineWidth <= 1)
                        extras = 0;
                else if ((dh != 0) && (dw != 0)) {
                        alpha = atan((double)dw/dh);
                        extras = (int)(line.lineWidth / sin((clPI*0.5) - alpha));
                }

                // y scan
                int ty1=y1;
                int ty2=y2;
                double raster=x1;

                if(y1>y2)
                {
                        ty1=y2;
                        ty2=y1;
                        raster=x2;
                }

                for(int y=ty1;y<=ty2;y++)
                {
                        int const ri=int(raster);

                        double const in_x0=1.0-(raster-ri);
                        double const in_x1=1.0-(ri+1-raster);

                        putTransPixel(ri+0, y, color, in_x0);
                        for (int n=0; n<extras; n++)
                                putTransPixel(ri+n+1, y ,color, 1.0);
                        putTransPixel(ri+extras+1, y, color, in_x1);

                        raster+=sly;
                }
        }
        return true;
}



bool Bitmap::canBeResizedTo(int w, int h) {
        double factor = 1.0;
        // Scale down

        if (w > 0) {
                // Scale down
                if (w < this->width) {
                        factor = getBestResizeFactor((double)w/this->width);
                }
                // Scale up
                else if (w > this->width) {
                        factor = getBestResizeFactor((double)w/this->width);
                }
                else
                        return false;
        }
        else {
                // Scale down
                if (h < this->height) {
                        factor = getBestResizeFactor((double)h/this->height);
                }
                // Scale up
                else if (h > this->height) {
                        factor = getBestResizeFactor((double)h/this->height);
                }
                else
                        return false;
        }

        int newWidth = (int)(this->width * factor);
        int newHeight = (int)(this->height * factor);

        if ((newWidth == 0) || (newHeight == 0) )
                return false;
        else if ((newWidth == this->width) || (newHeight == this->height) )
                return false;
        else
                return true;
}

Bitmap* Bitmap::getResizedCopy(double scale) {

        if ( (scale <= 0) || (this->width == 0) || (this->height == 0) )
                return NULL;
        int newWidth, newHeight;
        double factor = 1.0;

        int scaleUp = 0;
        int scaleDown = 0;
        int scale66 = 0;
        factor = getBestResizeFactors(scale, scaleUp, scaleDown, scale66);

        newWidth = (int)(this->width * factor);
        if ((double)newWidth != (this->width * factor))
                newWidth++;
        newHeight = (int)(this->height * factor);
        if ((double)newHeight != (this->height * factor))
                newHeight++;

        if ((newWidth == 0) || (newHeight == 0) )
                return NULL;
        char* newData = this->createResizedData(newWidth, newHeight, scaleUp, scaleDown, scale66);
        if (newData == NULL)
                return NULL;

        Bitmap* bitmap = new Bitmap(newData, newWidth, newHeight, true);
        return bitmap;
}

Bitmap* Bitmap::getResizedCopy(int w, int h, bool proportional) {

        if ( (w == 0) || (h == 0) || (this->width == 0) || (this->height == 0) )
                return NULL;

        // Not yet...
        if (!proportional)
                return NULL;

        return getResizedCopy((double)w/this->width);
}

bool Bitmap::resizeTo(int w, int h, bool proportional) {
        Bitmap* bitmap = getResizedCopy(w, h, proportional);
        if (bitmap == NULL)
                return false;
        takeDataFromBitmap(bitmap);
        delete(bitmap);
        return true;
}

double Bitmap::getBestResizeFactors(double factor, int &scaleUp, int &scaleDown, int &scale66) {
        // in search of best 2^a * (3/2)^b = factor
        // penalties: a > 0 : 0
        // penalties: b > 0 : a+b
        // penalties: c > 0 : 0.5*c
        // penalties: c < 0 : c
        // penalties: err * max

        double penalty;
        double err;
        double f;
        int max = (int)fabs(factor) + 5;

        double best_penalty = 9999;
        double best_factor = 0;
        int best_a = 0;
        int best_b = 0;
        int best_c = 0;

        for (int a=1; a<max; a++) {
                for (int b=1; b<max; b++) {
                        for (int c=-1; c<=1; c++) {
                                f = ((double)a/b) * pow(1.5, (double)c);
                                err = fabs(f - factor);

                                penalty = err * max * max;
                                if (c > 0)
                                        penalty += 0.5*c;
                                else if (c < 0)
                                        penalty += abs(c);
                                if (b > 0)
                                        penalty += a+b-2;
                                if (penalty < best_penalty) {
                                        best_a = (a-1);
                                        best_b = b;
                                        best_c = c;
                                        best_penalty = penalty;
                                        best_factor = f;
                                }
                        }
                }
        }
        if (best_penalty < 9999) {
                scaleUp = best_a;
                scaleDown = best_b;
                scale66 = best_c;
                return best_factor;
        }
        else
                return 0.0;
}

double Bitmap::getBestResizeFactor(double factor) {
        int scaleUp = 0;
        int scaleDown = 0;
        int scale66 = 0;
        double answer = getBestResizeFactors(factor, scaleUp, scaleDown, scale66);
        if (answer == 0)
                return factor;
        else
                return answer;
}

char* Bitmap::createResizedData(int newWidth, int newHeight, int scaleUp, int scaleDown, int scale66) {
        
        int w = this->width;
        int h = this->height;
        if ((scaleUp == 0) && (scaleDown == 0) && (scale66 == 0))
                return ImageResizeUp(this->data, w, h, 1);

        char* newData = NULL;
        char* tempData = NULL;

        if (scaleUp > 0) {
                newData = ImageResizeUp(this->data, w, h, scaleUp+1);
                if (scale66 == 1) {
                        tempData = newData;
                        newData = ImageResizeUp66(tempData, w, h);
                        delete [] tempData;
                }
                else if (scale66 == -1) {
                        tempData = newData;
                        newData = ImageResizeDown66(tempData, w, h);
                        delete [] tempData;
                }
                if (scaleDown > 1) {
                        tempData = newData;
                        newData = ImageResizeDown(tempData, w, h, scaleDown);
                        delete [] tempData;
                }
                return newData;
        }
        else if (scale66 == 1) {
                newData = ImageResizeUp66(this->data, w, h);
                if (scaleDown > 1) {
                        tempData = newData;
                        newData = ImageResizeDown(tempData, w, h, scaleDown);
                        delete [] tempData;
                }
                return newData;
        }
        else if (scale66 == -1) {
                newData = ImageResizeDown66(this->data, w, h);
                if (scaleDown > 1) {
                        tempData = newData;
                        newData = ImageResizeDown(tempData, w, h, scaleDown);
                        delete [] tempData;
                }
                return newData;
        }
        else if (scaleDown > 1) {
                newData = ImageResizeDown(this->data, w, h, scaleDown);
                return newData;
        }
        else
                return NULL;
}


bool Bitmap::copyDataFromBitmap(Bitmap* bitmap, bool shouldResize) {
        if (bitmap == NULL)
                return false;

        if ( (bitmap->width == this->width) && (bitmap->height == this->height) && (bitmap->size == this->size) ) {
                memcpy(this->data, bitmap->data, size);
                return true;
        }
        else if ( (bitmap->width == this->width) && (bitmap->height == this->height) ) {
                delete [] this->data;
                this->size = bitmap->size;
                this->data = new char[size];
                memcpy(this->data, bitmap->data, size);
                return true;
        }
        else if (!shouldResize) {
                delete [] this->data;
                this->size = bitmap->size;
                this->data = new char[size];
                memcpy(this->data, bitmap->data, size);
                return true;
        }
        else {
                Bitmap* bitmap2 = bitmap->getResizedCopy(this->width, this->height, true);
                if (bitmap2 == NULL)
                        return false;
                takeDataFromBitmap(bitmap2);
                delete(bitmap2);
                return true;
        }
}

bool Bitmap::takeDataFromBitmap(Bitmap* bitmap) {
        if (bitmap == NULL)
                return false;
        delete [] this->data;
        this->size = bitmap->size;
        this->width = bitmap->width;
        this->height = bitmap->height;
        this->data = bitmap->data;
        bitmap->data = NULL;
        bitmap->size = 0;
        bitmap->width = 0;
        bitmap->height = 0;
        return true;
}




/*
bool Bitmap::drawLine(Line line, Color color) {

        int x0 = (int) line.startPoint.x;
        int y0 = (int) line.startPoint.y;
        int x1 = (int) line.endPoint.x;
        int y1 = (int) line.endPoint.y;

//      int pix = color.getRGB();
        int dy = y1 - y0;
        int dx = x1 - x0;
        int stepx, stepy;
        double invD = ((dx==0)&&(dy==0)) ? 0.0 : 1.0/(2.0*sqrt((double)dx*dx+dy*dy));

        if (dy < 0) { dy = -dy;  stepy = -1; } else { stepy = 1; }
        if (dx < 0) { dx = -dx;  stepx = -1; } else { stepx = 1; }

        dy <<= 1;     // dy is now 2*dy
        dx <<= 1;     // dx is now 2*dx

        int fraction;
        int v2dx, v2dy;
        double dd, invD2dx, invD2dy;
        Color paintColor;
        Color backColor;
        
        if (dx > dy) {
                fraction = dy - (dx >> 1);
                v2dx = 0;
                invD2dx = dx * invD;
                backColor = getPixelColor(x0, y0);
                paintColor = color.mixOn(backColor, 1);
                setPixel(x0, y0, paintColor.r, paintColor.g, paintColor.b);
                backColor = getPixelColor(x0, y0 + stepy);
                paintColor = color.mixOn(backColor, 1 - invD2dx);
                setPixel(x0, y0 + stepy, paintColor.r, paintColor.g, paintColor.b);
                backColor = getPixelColor(x0, y0 - stepy);
                paintColor = color.mixOn(backColor, 1 - invD2dx);
                setPixel(x0, y0 - stepy, paintColor.r, paintColor.g, paintColor.b);
                while (x0 != x1) {
                        v2dx = fraction;
                        if (fraction >= 0) {
                                y0 += stepy;
                                v2dx -= dx;
                                fraction -= dx;
                        }
                        x0 += stepx;
                        v2dx += (dx >> 1);
                        fraction += dy;
                        dd = v2dx * invD;

                        backColor = getPixelColor(x0, y0);
                        paintColor = color.mixOn(backColor, 1 - dd);
                        setPixel(x0, y0, paintColor.r, paintColor.g, paintColor.b);
                        backColor = getPixelColor(x0, y0 + stepy);
                        paintColor = color.mixOn(backColor, 1 - (invD2dx - dd));
                        setPixel(x0, y0 + stepy, paintColor.r, paintColor.g, paintColor.b);
                        backColor = getPixelColor(x0, y0 - stepy);
                        paintColor = color.mixOn(backColor, 1 - (invD2dx + dd));
                        setPixel(x0, y0 - stepy, paintColor.r, paintColor.g, paintColor.b);
                }
        }
        else {
                fraction = dx - (dy >> 1);
                v2dy = 0;
                invD2dy = dy * invD;
                setPixel(x0, y0, 0, 0, 0);
                setPixel(x0, y0 + stepy, (int) invD2dy, (int) invD2dy, (int) invD2dy);
                setPixel(x0, y0 - stepy, (int) invD2dy, (int) invD2dy, (int) invD2dy);
                while (y0 != y1) {
                        v2dy = fraction;
                        if (fraction >= 0) {
                                x0 += stepx;
                                v2dy -= dy;
                                fraction -= dy;
                        }
                        y0 += stepy;
                        v2dy += (dy >> 1);
                        fraction += dx;
                        dd = v2dy * invD;
                        setPixel(x0, y0, (int) dd, (int) dd, (int) dd);
                        setPixel(x0 + stepx, y0, (int) (invD2dy - dd), (int) (invD2dy - dd), (int) (invD2dy - dd));
                        setPixel(x0 - stepx, y0, (int) (invD2dy + dd), (int) (invD2dy + dd), (int) (invD2dy + dd));
                //      setPixel(x0, y0, 0, 0, 0);
                //      setPixel(x0 + stepx, y0, 0, 0, 0);
                //      setPixel(x0 - stepx, y0, 0, 0, 0);
                }
        }

        setBitmapChanged();
        return true;
}
*/

bool Bitmap::drawLine(const PolyLine& polyline, const Color& color) {
        for (int n=0; n<polyline.getLineCount(); n++) {
                drawLine(polyline.getLine(n), color);
        }
        setBitmapUpdated();
        return true;
}

bool Bitmap::drawBox(const Box& box, const Color& color) {
        Line line = Line(box.getUpperLeft(), box.getUpperRight());
        drawLine(line, color);
        line = Line(box.getUpperRight(), box.getLowerRight());
        drawLine(line, color);
        line = Line(box.getLowerRight(), box.getLowerLeft());
        drawLine(line, color);
        line = Line(box.getLowerLeft(), box.getUpperLeft());
        drawLine(line, color);
        addBitmapUpdateRegion(box);
        return true;
}

// static void WUCircle(int cx,int cy, int R, int filled, int c)

bool Bitmap::putQuadPixel(int xCenter, int yCenter, int x, int y, const Color& color, double weight) {
        putTransPixel(xCenter + y, yCenter + x, color, weight);
        putTransPixel(xCenter - y, yCenter + x, color, weight);
        putTransPixel(xCenter + y, yCenter - x, color, weight);
        putTransPixel(xCenter - y, yCenter - x, color, weight);
        putTransPixel(xCenter + x, yCenter + y, color, weight);
        putTransPixel(xCenter - x, yCenter + y, color, weight);
        putTransPixel(xCenter + x, yCenter - y, color, weight);
        putTransPixel(xCenter - x, yCenter - y, color, weight);
        return true;
}


bool Bitmap::drawCircle(int xCenter, int yCenter, int radius, const Color& color, double weight, double lineWidth, bool filled) {

        if ((((int)lineWidth) > 1) && (!filled)) {
                for (int n=0-(round(lineWidth/2)); n<round(lineWidth/2); n++) {
                        drawCircle(xCenter, yCenter, radius+n, color, weight, 1);
                }
                return true;
        }

        #define D(r,y) (ceil(sqrt((double)r*r - y*y)) - sqrt((double)r*r - y*y))

        int x = radius;
        int y = 0;
        int ax;
        double T = 0;
        double I = 0.93;
        if (filled)
                for(ax=0; ax<x; ++ax)
                        putQuadPixel(xCenter, yCenter, ax, y, color, 1.0);

        putQuadPixel(xCenter, yCenter, x, y, color, I);

        while (x>y)
        {
                ++y;
                if (D(radius,y) < T) --x;
                putQuadPixel(xCenter, yCenter, x, y, color, I*(1-D(radius,y)));
                if (!filled) {
                        putQuadPixel(xCenter, yCenter, x-1, y, color, I*(1-D(radius,y)));
                }
                if (filled) {
                        for(ax=0; ax<x; ++ax)
                                putQuadPixel(xCenter, yCenter, ax, y, color, 1.0);
                }
                T = D(radius,y);
        }

        return true;
/*
        int x=0;
        int y=radius;
        int p=(5-(radius<<2))>>2; //Midpoint Algorithm

        putTransPixel(xCenter  , yCenter+y, color, weight);
        putTransPixel(xCenter  , yCenter-y, color, weight);
        putTransPixel(xCenter+y, yCenter  , color, weight);
        putTransPixel(xCenter-y, yCenter  , color, weight);
        
        while(x++ < y) {
                if(p<0)
                        p+=1+(x<<1);
                else
                        p+=1+((x- --y)<<1);

                if(x<y) {
                        putTransPixel(xCenter+x, yCenter+y, color, weight);
                        putTransPixel(xCenter-x, yCenter+y, color, weight);
                        putTransPixel(xCenter+x, yCenter-y, color, weight);
                        putTransPixel(xCenter-x, yCenter-y, color, weight);
                        putTransPixel(xCenter+y, yCenter+x, color, weight);
                        putTransPixel(xCenter-y, yCenter+x, color, weight);
                        putTransPixel(xCenter+y, yCenter-x, color, weight);
                        putTransPixel(xCenter-y, yCenter-x, color, weight);
                }
                else if(x==y) {
                        putTransPixel(xCenter+x, yCenter+y, color, weight);
                        putTransPixel(xCenter-x, yCenter+y, color, weight);
                        putTransPixel(xCenter+x, yCenter-y, color, weight);
                        putTransPixel(xCenter-x, yCenter-y, color, weight);
                }
        }
        return true;*/
}



bool Bitmap::drawBitmap(Bitmap* bitmap, int srcx, int srcy, int dstx, int dsty, int w, int h) {
        if ( (bitmap == NULL) || (bitmap->data == NULL) || (bitmap == this) )
                return false;

        if (srcx < 0)
                srcx = 0;
        if (srcy < 0)
                srcy = 0;

        int byteWidth = width*4;
        int srcByteWidth = bitmap->width * 4;

        int srcStartX = srcx;
        if (dstx < 0) {
                srcStartX -= dstx;
                dstx = 0;
        }
        int srcStartY = srcy;
        if (dsty < 0) {
                srcStartY -= dsty;
                dsty = 0;
        }

        if (w > bitmap->width - srcStartX)
                w = bitmap->width - srcStartX;
        if (h > bitmap->height - srcStartY)
                h = bitmap->height - srcStartY;
        
        if (w + dstx > width)
                w = width - dstx;
        if (h + dsty > height)
                h = height - dsty;
        if ( (w < 0) || (h < 0) )
                return false;

//      int copybytes = (w - srcStartX) * 4;
        int copybytes = w * 4;
        char* src = bitmap->data + (srcStartY*srcByteWidth + (srcStartX*4));
        char* dst = data + (dsty*byteWidth + (dstx*4));
//      for (int n=0; n < h - srcStartY; n++) {
        for (int n=0; n < h; n++) {
                memcpy(dst, src, copybytes);
                src += srcByteWidth;
                dst += byteWidth;
        }
        addBitmapUpdateRegion(Box(dstx, dsty, w, h));
        return true;
}





bool Bitmap::drawBitmap(Bitmap* bitmap, int x, int y) {
        if (bitmap == NULL)
                return false;
        bitmap->addBitmapUpdateRegion(Box(x, y, bitmap->width, bitmap->height));
        return drawBitmap(bitmap, x, y, bitmap->width, bitmap->height);
}

bool Bitmap::drawBitmap(Bitmap* bitmap, int x, int y, int w, int h) {
        if ( (bitmap == NULL) || (bitmap->data == NULL) || (bitmap == this) )
                return false;

        return drawBitmap(bitmap, 0, 0, x, y, w, h);
/*

        int byteWidth = width*4;
        int srcByteWidth = bitmap->width * 4;

        int srcStartX = 0;
        if (x < 0) {
                srcStartX -= x;
                x = 0;
        }
        int srcStartY = 0;
        if (y < 0) {
                srcStartY -= y;
                y = 0;
        }

        if (w > bitmap->width + srcStartX)
                w = bitmap->width - srcStartX;
        if (h > bitmap->height + srcStartY)
                h = bitmap->height - srcStartY;
        
        if (w + x > width)
                w = width - x;
        if (h + y > height)
                h = height - y;
        if ( (w < 0) || (h < 0) )
                return false;

        int copybytes = (w - srcStartX) * 4;
        char* src = bitmap->data + (srcStartY*srcByteWidth + (srcStartX*4));;
        char* dst = data + (y*byteWidth + (x*4));
        for (int n=0; n < h - srcStartY; n++) {
                memcpy(dst, src, copybytes);
                src += srcByteWidth;
                dst += byteWidth;
        }
        bitmap->addBitmapUpdateRegion(Box(x, y, w, h));
        return true;*/
}

bool Bitmap::drawBitmap(Bitmap* bitmap, const Point& p) {
        return drawBitmap(bitmap, p.x, p.y);
}

bool Bitmap::drawBitmap(Bitmap* bitmap, const Box& box) {
        return drawBitmap(bitmap, (int) box.getLeftX(), (int) box.getUpperY(), (int) box.getWidth(), (int) box.getHeight());
}















//////////////////////////////////////////////////////////////////////
// Advanced Functions
//////////////////////////////////////////////////////////////////////

/*
// Rotate around the center point
bool Bitmap::rotate(double angle) {

        double a, b, c;
        int x1, y1, x2, y2, x3, y3;

        long tdiff = 0;
        
        double r = sqrt((double)width*width + height*height);
        int cr = (int) ceil(r) + 8;

        if (altBitmap == NULL) 
                altBitmap = new Bitmap(cr, cr);

        if ( (altBitmap->width != cr) ||
                 (altBitmap->height != cr) ) {
                delete(altBitmap);
                altBitmap = new Bitmap(cr, cr);
        }
        altBitmap->eraseBitmap(bgColor.r, bgColor.g, bgColor.b);
//      altBitmap->eraseBitmap(200, 200, 200);
//      altBitmap->eraseBitmap(255, 0, 0);

        r = (r/2); // - (r/8);
//      r = (r/3); // - (r/8);
//      angle = (clPI/4.0);

        double alpha = asin(width/(2.0*r));
        double beta = 2.0*acos(width/(2.0*r));

        a = angle + (clPI/2) + alpha;
        if (a > clPI) a = a - (2*clPI);

        b = angle + (clPI/2) - alpha;
        if (b > clPI) b = b - (2*clPI);
        
        c = angle + (clPI/2) + alpha + beta;
        if (c > clPI) c = c - (2*clPI);

        x1 = round(r * (1.0 + cos(a))) + 4;
        y1 = round(r * (1.0 - sin(a))) + 4;
        x2 = round(r * (1.0 + cos(b))) + 4;
        y2 = round(r * (1.0 - sin(b))) + 4;
        x3 = round(r * (1.0 + cos(c))) + 4;
        y3 = round(r * (1.0 - sin(c))) + 4;

        //      shapeSlow(x1, y1, x2, y2, x3, y3);
        shape(x1, y1, x2, y2, x3, y3);

        return true;
}


// Rotate around the center point
bool Bitmap::rotateSlow(double angle) {

        double a, b, c;
        int x1, y1, x2, y2, x3, y3;

        long tdiff = 0;
        
        double r = sqrt((double)width*width + height*height);
        int cr = (int) ceil(r) + 8;

        if (altBitmap == NULL) 
                altBitmap = new Bitmap(cr, cr);

        if ( (altBitmap->width != cr) ||
                 (altBitmap->height != cr) ) {
                delete(altBitmap);
                altBitmap = new Bitmap(cr, cr);
        }
        altBitmap->eraseBitmap(bgColor.r, bgColor.g, bgColor.b);
//      altBitmap->eraseBitmap(200, 200, 200);
//      altBitmap->eraseBitmap(255, 0, 0);

        r = (r/2); // - (r/8);
//      r = (r/3); // - (r/8);
//      angle = (clPI/4.0);

        double alpha = asin(width/(2.0*r));
        double beta = 2.0*acos(width/(2.0*r));

        a = angle + (clPI/2) + alpha;
        if (a > clPI) a = a - (2*clPI);

        b = angle + (clPI/2) - alpha;
        if (b > clPI) b = b - (2*clPI);
        
        c = angle + (clPI/2) + alpha + beta;
        if (c > clPI) c = c - (2*clPI);

        x1 = round(r * (1.0 + cos(a))) + 4;
        y1 = round(r * (1.0 - sin(a))) + 4;
        x2 = round(r * (1.0 + cos(b))) + 4;
        y2 = round(r * (1.0 - sin(b))) + 4;
        x3 = round(r * (1.0 + cos(c))) + 4;
        y3 = round(r * (1.0 - sin(c))) + 4;

        shapeSlow(x1, y1, x2, y2, x3, y3);
        // shape(x1, y1, x2, y2, x3, y3);

        return true;
}


bool Bitmap::shapeSlow(int x1, int y1, int x2, int y2, int x3, int y3) {
        
        double px, py;
        long pos, n, altbyteWidth;

//      byteWidth = width * byteDepth + padding;
        altbyteWidth = (altBitmap->width*altBitmap->byteDepth);

        BYTE c[6];
        c[0] = (BYTE) 0;
        c[1] = (BYTE) 0;
        c[2] = (BYTE) 0;
        c[3] = (BYTE) 0;
        c[4] = (BYTE) 0;
        c[5] = (BYTE) 0;
        
        double d1x = ((double)(x2 - x1)) / width;
        double d1y = ((double)(y2 - y1)) / width;

        double d2x = ((double)(x3 - x1)) / height;
        double d2y = ((double)(y3 - y1)) / height;
        
        double ppx, ppy;

        long startLine = size;

        px = ppx = x1;// + (y * d2x) + (x * d1x);
        py = ppy = y1;// + (y * d2y) + (x * d1y);
        for (int y=0; y < height; y++) {
                n = (startLine -= byteWidth); // y * byteWidth;
                for (int x=0; x < width; x++) {
                        if ((n == 0) || (x == 0)) {
                                pos = ((altBitmap->height-(long)py) * altbyteWidth) + ((long)px * byteDepth);
                                memcpy(altBitmap->data+pos, data+n, 3);
                        }
                        else if ((n > 0) && (n < size)) {
                                pos = ((altBitmap->height-(long)py) * altbyteWidth) + ((long)px * byteDepth);
                                memcpy(altBitmap->data+pos-3, data+n-3, 6);
                        //      memcpy(altBitmap->data+pos-3, c, 6);
                        }
                        n += 3;
                        px += d1x; // + (x * d1x);
                        py += d1y; // + (x * d1y);
                }
                px = (ppx += d2x);
                py = (ppy += d2y);
        }

//      int x4 = x3 + (x2-x1);
//      int y4 = y3 - (y1-y2);
//      for (int k=-5; k<5; k++) {
//              altBitmap->setPixel(x1+k, y1+k, 0, 255, 0);
//              altBitmap->setPixel(x2+k, y2+k, 255, 0, 0);
//              altBitmap->setPixel(x3+k, y3+k, 255, 0, 0);
//              altBitmap->setPixel(x4+k, y4+k, 255, 0, 0);
//              altBitmap->setPixel(x1+k, y1-k, 0, 255, 0);
//              altBitmap->setPixel(x2+k, y2-k, 255, 0, 0);
//              altBitmap->setPixel(x3+k, y3-k, 255, 0, 0);
//              altBitmap->setPixel(x4+k, y4-k, 255, 0, 0);
//      }
        return true;
}




bool Bitmap::shape(int x1, int y1, int x2, int y2, int x3, int y3) {
        double px, py;
//      double ppx, ppy;
        long pos, oldpy, n;

//      long byteWidth = width * byteDepth + padding;
        long altbyteWidth = (altBitmap->width*altBitmap->byteDepth);

//      double d1x = ((double)(x2 - x1)) / width;
//      double d1y = ((double)(y2 - y1)) / height;

//      double d2x = ((double)(x3 - x1)) / width;
//      double d2y = ((double)(y3 - y1)) / height;

        double d1x = ((double)(x2 - x1)) / width;
        double d1y = ((double)(y2 - y1)) / width;

        double d2x = ((double)(x3 - x1)) / height;
        double d2y = ((double)(y3 - y1)) / height;

        long startLine = size;
        long nStart, posStart;
        int length;
        bool inverted = false;

//      altBitmap->eraseBitmap(200, 200, 200);
        
        // nStart is upper left corner of original bitmap
        nStart = size - byteWidth;
        // posStart is the equivalent rotated upper left corner = (x1,y1)
        posStart = ((altBitmap->height-y1) * altbyteWidth) + (x1 * byteDepth);

        length = 0;
        px = x1 + (0 * d2x);// + (y * d2x) + (x * d1x);
        py = y1 + (0 * d2y);// + (y * d2y) + (x * d1y);
        n = nStart;
        for (int x=0; x < width; x++) {
                if ((n >= 0) && (n < size)) {
                        pos = ((altBitmap->height-(long)py) * altbyteWidth) + ((long)px * byteDepth);
                        if ((oldpy == (long)py) && ((y3 - y1) > 0)) {
                                length--;
                                L[length] += 3;
                        }
                        else {
                                N[length] = n - nStart;
                                P[length] = pos - posStart;
                                L[length] = 3;
                        }
                        length++;
                }
                n += 3;
                oldpy = (long)py;
                px += d1x; // + (x * d1x);
                py += d1y; // + (x * d1y);
        }
        // Make sure first pixel does not get black from outside
        if (length > 0) {
                N[0] += 3;
                L[0] -= 3;
        //      P[0] += 3;
        }

        long posLineStart = posStart;
        long nLineStart = nStart;
        px = x1; // + d2x; // + (0 * d2x);
        py = y1; // + d2y; // + (0 * d2y);
        for (int y=0; y < height; y++) {
                for (n=0; n<length; n++) {
                        memcpy(altBitmap->data+P[n]+posLineStart-3, data+N[n]+nLineStart-3, L[n]+3);
                }
                nLineStart -= byteWidth;
                px += d2x;
                py += d2y;
                posLineStart = ((altBitmap->height-(long)py) * altbyteWidth) + ((long)px * byteDepth);
        }

//      int x4 = x3 + (x2-x1);
//      int y4 = y3 - (y1-y2);
//      for (int k=-5; k<5; k++) {
//              altBitmap->setPixel(x1+k, y1+k, 0, 0, 255);
//              altBitmap->setPixel(x2+k, y2+k, 255, 0, 0);
//              altBitmap->setPixel(x3+k, y3+k, 255, 0, 0);
//              altBitmap->setPixel(x4+k, y4+k, 255, 0, 0);
//              altBitmap->setPixel(x1+k, y1-k, 0, 0, 255);
//              altBitmap->setPixel(x2+k, y2-k, 255, 0, 0);
//              altBitmap->setPixel(x3+k, y3-k, 255, 0, 0);
//              altBitmap->setPixel(x4+k, y4-k, 255, 0, 0);
//      }
        return true;
}
*/


//////////////////////////////////////////////////////////////////////
// File Routines
//////////////////////////////////////////////////////////////////////

bool Bitmap::readFromFile(const JString& filename) {

        BITMAPFILEHEADER bmfh ={0};
        BITMAPINFOHEADER bmih ={0};
        long count = 0;

        int len;
        char* dat = JFile::readAFileBinary(filename, len);
        if (dat == NULL) {
        //      printf("No file data\n");
                return false;
        }

        char* src = dat;
        
//      bmfh = (BITMAPFILEHEADER*) src;
        memcpy(&bmfh, src, sizeof(bmfh)); /* read bitmap file header */
        src += sizeof(BITMAPFILEHEADER);
//      bmih = (BITMAPINFOHEADER*) src;
        memcpy(&bmih, src, sizeof(bmih)); /* read bitmap info header */
        src += sizeof(BITMAPINFOHEADER);

//      MessageBox(NULL, JString::format("Read binary file len %d [%d %d]", len, (int)bmfh, (int)bmih), JString("WinClient"), MB_OK);
//      MessageBox(NULL, JString::format("Bitmap: %d %d %d %d \n", sizeof(BITMAPFILEHEADER), sizeof(BITMAPINFOHEADER), bmfh.bfSize, bmfh.bfOffBits), JString("WinClient"), MB_OK);
//      printf("Bitmap: %d %d %d %d %d \n", sizeof(BITMAPFILEHEADER), sizeof(BITMAPINFOHEADER), bmfh->bfSize, bmfh->bfType, bmfh->bfOffBits);

//      MessageBox(NULL, JString("Analysing binary file "), JString("WinClient"), MB_OK);
        if (bmih.biCompression != 0) {
//              MessageBox(NULL, JString("auch, compression"), JString("WinClient"), MB_OK);
                delete [] dat;
        //      printf("Compression\n");
                return false;
        }
        
//      MessageBox(NULL, JString("Is it 24 bit?"), JString("WinClient"), MB_OK);
        if (bmih.biBitCount != 24) {
//              MessageBox(NULL, JString("auch, !24"), JString("WinClient"), MB_OK);
                delete [] dat;
        //      printf("Not 24 bits: %d\n", bmih.biBitCount);
                return false;
        }

/*      if (bmih.biBitCount <= 8) {
                // determine type of window bitmaps
                if(bmih.biBitCount==8) bmpcolour=256;
                if(bmih.biBitCount==4) bmpcolour=16;
                if(bmih.biBitCount==1) bmpcolour=2;

                // * * * * * * * * * * * * * * * * * *
                 read the palette information
                 from MSB b,g,r,i (i=ignore)
                // * * * * * * * * * * * * * * * * * * *
                
                for(index=0;index<bmpcolour;index++)
                {
                        pal3[index].b = fgetc(fp) >> 2;
                        pal3[index].g = fgetc(fp) >> 2;
                        pal3[index].r = fgetc(fp) >> 2;
                        fgetc(fp);
                }
        }*/

//      MessageBox(NULL, JString("24 bit OK"), JString("WinClient"), MB_OK);
        int depth = bmih.biBitCount;
        int planes = bmih.biPlanes;
        int width = bmih.biWidth;
        int height = bmih.biHeight;
//      MessageBox(NULL, JString::format("D: %d, P: %d, W: %d, H: %d", depth, planes, width, height), JString("WinClient"), MB_OK);
//      byteDepth = (int) (depth/8);
//      byteWidth = width * byteDepth + padding;

        if(bmih.biSizeImage==0)
                bmih.biSizeImage=bmfh.bfSize - bmfh.bfOffBits;

//      div_t d = div(width, 4);
//      int padding = d.rem;

//      MessageBox(NULL, JString("Reinit bitmap "), JString("WinClient"), MB_OK);
        init(width, height);
        if (data == NULL) {
        //      printf("No data\n");
                return false;
        }

//      MessageBox(NULL, JString("Converting data "), JString("WinClient"), MB_OK);
        convertBitmapFileData(src, width, height, (int)(bmih.biBitCount/8), data, size);
//      MessageBox(NULL, JString("Converted data "), JString("WinClient"), MB_OK);

        delete [] dat;
        setBitmapUpdated();
        return true;
}

bool Bitmap::saveToFile(const JString& filename) {
        FILE *fp;

        // Open file
        if((fp=fopen(filename,"wb"))==NULL)
                return false;

        int len = 0;
        char* buffer = toBitmapFileFormat(len);
        if ( (len <= 0) && (buffer == NULL) ) {
                delete [] buffer;
                fclose(fp);
                return false;
        }

        if (fwrite(buffer, len, 1, fp) != 1) {
                delete [] buffer;
                fclose(fp);
                return false;
        }

        delete [] buffer;
        fclose(fp);
        return true;

/*
        BITMAPFILEHEADER bmfh={0};
        // BITMAPINFOHEADER bmih={0};
        BITMAPINFOHEADER* info;
//      int infosize = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER) + 2;  // + 2 for rounding
        int infosize = sizeof(BITMAPINFOHEADER) + 2;  // + 2 for rounding

//      DWORD index;
//      BYTE ch;
        long count = 0;

        int byteWidth = width*4;

        // Fill out structures
        bmfh.bfType = 19778; // 'BM'
        bmfh.bfSize = size + sizeof(BITMAPFILEHEADER) + infosize; // might need padding...
        bmfh.bfReserved1 = 0;
        bmfh.bfReserved2 = 0;
        bmfh.bfOffBits = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER);

        info = (BITMAPINFOHEADER*) malloc(infosize);
        memset(info, 0, infosize);

        info->biSize = sizeof(BITMAPINFOHEADER);
        info->biWidth = width;
        info->biHeight = height;
        info->biPlanes = 1;
        info->biCompression = 0;
        info->biBitCount = 24;
        info->biSizeImage = 0; // size;
        info->biXPelsPerMeter = 2834;
        info->biYPelsPerMeter = 2834;
        info->biClrUsed = 0;
        info->biClrImportant = 0;

        // div_t d = div(width, 4);
        // int padding = d.rem;
        int padding = 4 - ((width*3)%4);
        if (padding == 4) padding = 0;

        // write bitmap file header
        if (fwrite(&bmfh,sizeof(BITMAPFILEHEADER),1,fp) != 1) { 
                fclose(fp);
                free(info);
                return false;
        }

        // write bitmap info header
//      if (fwrite(&bmih,sizeof(bmih),1,fp) != 1) { 
        if (fwrite(info, sizeof(BITMAPINFOHEADER),1,fp) != 1) { 
                fclose(fp);
                free(info);
                return false;
        }

        free(info);

//      char* binline = new char[byteWidth];
//      memset(binline, 0, byteWidth);

        // Write bitmap data
        int c, x;
        char* src = data + (height-1) * byteWidth;
        for (int l = 0; l < height; l++)
        {
        //      fwrite(binline, 1, byteWidth, fp);
                x = 0;
                for (c = 0; c < width; c++) {
                        fputc(src[x+2], fp);
                        fputc(src[x+1], fp);
                        fputc(src[x], fp);
                        x += 4;
                }
                for (c=0; c < padding; c++) {
                        fputc(0, fp);
                }
                src -= byteWidth;
        }

        // Close file
        fclose(fp);
        return true; */
}

char* Bitmap::toBitmapFileFormat(int& len) {
        BITMAPFILEHEADER bmfh={0};
        BITMAPINFOHEADER* info;
        int infosize = sizeof(BITMAPINFOHEADER) + 2;  // + 2 for rounding

        long count = 0;
        int byteWidth = width*4;

        int padding = 4 - ((width*3)%4);
        if (padding == 4) padding = 0;

        len = sizeof(BITMAPFILEHEADER) + infosize + (height * width * 3) + (padding * height);
        char* buffer = new char[len];
        char* dst = buffer;

        // Fill out structures
        bmfh.bfType = 19778; // 'BM'
//      bmfh.bfSize = size + sizeof(BITMAPFILEHEADER) + infosize; // might need padding...
        bmfh.bfSize = len;
        bmfh.bfReserved1 = 0;
        bmfh.bfReserved2 = 0;
        bmfh.bfOffBits = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER);

        info = (BITMAPINFOHEADER*) malloc(infosize);
        memset(info, 0, infosize);

        info->biSize = sizeof(BITMAPINFOHEADER);
        info->biWidth = width;
        info->biHeight = height;
        info->biPlanes = 1;
        info->biCompression = 0;
        info->biBitCount = 24;
        info->biSizeImage = 0; // size;
        info->biXPelsPerMeter = 2834;
        info->biYPelsPerMeter = 2834;
        info->biClrUsed = 0;
        info->biClrImportant = 0;


        // write bitmap file header
        memcpy(dst, &bmfh, sizeof(BITMAPFILEHEADER));
        dst += sizeof(BITMAPFILEHEADER);

        memcpy(dst, info, sizeof(BITMAPINFOHEADER));
        dst += sizeof(BITMAPINFOHEADER);

        free(info);

        // Write bitmap data
        int c, x;
        char* src = data + (height-1) * byteWidth;
        for (int l = 0; l < height; l++)
        {
                x = 0;
                for (c = 0; c < width; c++) {
                        *dst++ = src[x+2];
                        *dst++ = src[x+1];
                        *dst++ = src[x];
                        x += 4;
                }
                for (c=0; c < padding; c++) {
                        *dst++ = 0;
                }
                src -= byteWidth;
        }
        return buffer;
}


//////////////////////////////////////////////////////////////////////
// Math Helper Routines
//////////////////////////////////////////////////////////////////////

int Bitmap::round(double d) {

        double f = floor(d);

        if ((d - f) < 0.5000)
                return (int) f;
        else
                return (int) (f+1);
}























HTMLPage* Bitmap::toHTMLBitmap() {
        return new HTMLPage(this);
}

JString Bitmap::toHTML() {
        return JString::format("Bitmap size %d bytes, time %s", size, (char*) timestamp.print());
}


JString Bitmap::toXML() {
        return "<bitmap />";
}

bool Bitmap::fromXML(XMLNode* node) {

        if (node == NULL)
                return false;

        if (!node->getTag().equalsIgnoreCase("bitmap"))
                return false;

        return true;    
}




















bool Bitmap::convertBitmapFileData(char* src, int width, int height, int depth, char* dst, long dstlen) {

        int c;
        int len = width*depth;
        int padding = 4 - (len%4);
        if (padding == 4) padding = 0;
        int lineWidth = len + padding;
        int offset = padding - (2*lineWidth);

        unsigned char* newsrc = (unsigned char*) (src + ((height-1) * lineWidth));
        unsigned int* newdst = (unsigned int*) dst;

        for (int l = 0; l < height; l++)
        {
                for (c = 0; c < width; c++) {
                        *(newdst++) = ((unsigned int)((newsrc[0] << 16) | (newsrc[1] << 8) | (newsrc[2] << 0)));
                        newsrc += depth;
                }
                newsrc += offset;
        }

        return true;
}

char* Bitmap::convertBitmapFileDataRunLength(char* src, int width, int height, int depth, long &dstlen) {

//      src = "012345678900000000001234567890";
//      height = 1;
//      width = 30;

        char* dst = new char[width*height*4 + 100];

        int c;
        int padding = 4 - ((width*depth)%4);
        if (padding == 4) padding = 0;
        int lineWidth = width*depth + padding;
        int offset = padding - (2*lineWidth);

        unsigned char* newsrc = (unsigned char*) (src + ((height-1) * lineWidth));
        unsigned int* newdst = (unsigned int*) dst;
        unsigned int* lastCtrl = newdst;
        
        int pos = 1;
        int length = 0;

        bool isInRL = false;

//      int n;
/*      for (n=0; n<30; n++) {
                printf("[ %c] ", (char)src[n]);
        }
        printf("\n");*/

        //int len = 0;

        for (int l = 0; l < height; l++)
        {
                for (c = 0; c < width; c++) {
                        newdst[pos] = ((unsigned int)((newsrc[0] << 16) | (newsrc[1] << 8) | (newsrc[2] << 0)));

                        if (isInRL) {
                                if (newdst[pos-1] == newdst[pos]) {
                                        // Continue RL
                                        pos--;
                                }
                                else {
                                        // End RL
                                        *lastCtrl = (unsigned int)((RLECTRL << 24) | length);
                                //      len += length;
                                        length = 0;
                                        lastCtrl += 2;
                                        pos++;
                                        newdst[pos] = newdst[pos-1];
                                        isInRL = false;
                                }
                        }
                        else {
                                if ( (length > 1) && (newdst[pos-2] == newdst[pos-1]) && (newdst[pos-1] == newdst[pos]) ) {
                                        if (length == 2) {
                                                // No data series, switch to RL
                                                pos -= 2;
                                        }
                                        else {
                                                // Close previous series
                                                *lastCtrl = (unsigned int)((DATACTRL << 24) | (length - 2));
                                        //      len += length - 2;
                                                lastCtrl += length - 1;
                                                length = 2;
                                                pos--;
                                        }
                                        isInRL = true;
                                }
                                else {
                                        // Just continue
                                }
                        }
                        pos++;
                        length++;
                        newsrc += depth;
                }
                newsrc += offset;
        }
        if (isInRL) {
                *lastCtrl = (unsigned int)((RLECTRL << 24) | length);
        //      len += length;
        }
        else {
                *lastCtrl = (unsigned int)((DATACTRL << 24) | length);
        //      len += length;
        }
        dstlen = pos * 4;

/*      for (n=0; n<30; n++) {
                printf("[ %c] ", (char)dst[n]);
        }
        printf("\n");*/

/*      int ctrl;
        len = 0;
        int totallen = 0;
        pos = 0;
        while (pos < (dstlen/4)) {
                ctrl = (newdst[pos] >> 24);
                len = (newdst[pos] & 0xFFFFFF);
                pos++;
                if (ctrl == 1) {
                //      printf("Data[%d] ", len);
                //      for (int k=0; k<len; k++)
                //              printf("%c ", (char) newdst[pos+k]);
                        totallen += len;
                        pos += len;
                }
                else if (ctrl == 2) {
//                      printf("RLE[%d] %d ", len, (int) newdst[pos]);
                        totallen += len;
                        pos++;
                }
                else {
                        printf("Wrong CTRL: %d ", ctrl);
                        pos++;
                }
        }
*/

/*      pos = 0;
        totallen = 0;
        while (pos < dstlen) {
                ctrl = (newdst[pos] >> 24);
                len = (newdst[pos] & 0xFFFFFF);
                pos++;
                if (ctrl == 1) {
                        totallen += len;
                        printf("Data[%d] (%d) ", len, totallen);
                //      for (int k=0; k<len; k++)
                //              printf("%c ", (char) newdst[pos+k]);
                        pos += len;
                }
                else if (ctrl == 2) {
                        totallen += len;
                        printf("RLE[%d] (%d) ", len, totallen);
                        pos++;
                }
                else {
                        printf("Wrong CTRL: %d ", ctrl);
                        pos++;
                }
        }
*/

        return dst;
}

char* Bitmap::differenceBitmapFileData(char* orig, char* src, int width, int height, int depth, long &dstlen) {

/*      orig = "987654321100000000009876543211";
        src  = "012345678900000000001234567890";
        height = 1;
        width = 30;
*/
        char* dst = new char[width*height*4 + 100];

        int c;
        int padding = 4 - ((width*depth)%4);
        if (padding == 4) padding = 0;
        int lineWidth = width*depth + padding;
        int offset = padding - (2*lineWidth);

        unsigned char* newsrc = (unsigned char*) (src + ((height-1) * lineWidth));
        unsigned int* newdst = (unsigned int*) dst;
        unsigned int* org = (unsigned int*) orig;
        // unsigned char* org = (unsigned char*) orig;
        unsigned int* lastCtrl = newdst;
        
        int pos = 1;
        int length = 0;
        int dlength = 0;

        bool isInDif = false;

/*      int n;
        for (n=0; n<30; n++) {
                newdst[n] = 0;
        }*/

        //int len = 0;
        for (int l = 0; l < height; l++)
        {
                for (c = 0; c < width; c++) {
                        newdst[pos] = ((unsigned int)((newsrc[0] << 16) | (newsrc[1] << 8) | (newsrc[2] << 0)));
                //      newdst[pos] = src[c];

                /*      for (n=0; n<30; n++) {
                                printf("[%.2d] ", newdst[n]);
                        }
                        printf("\n");*/

                        if (isInDif) {
                                if (*org == newdst[pos]) {
                                        // Continue Dif
                                        pos--;
                                }
                                else {
                                        // End Dif
                                        *lastCtrl = (unsigned int)((DIFCTRL << 24) | length);
                                //      len += length;
                                        length = 0;
                                        lastCtrl++;
                                        pos++;
                                        newdst[pos] = newdst[pos-1];
                                        isInDif = false;
                                }
                        }
                        else {
                                if (*org == newdst[pos]) {
                                        if (pos == 1) {
                                                pos--;
                                                isInDif = true;
                                        }
                                        else {
                                                // Close previous series
                                                *lastCtrl = (unsigned int)((DATACTRL << 24) | (length));
                                        //      len += length;
                                                lastCtrl += length + 1;
                                                length = 0;
                                                // pos--;
                                                isInDif = true;
                                        }
                                }
                                else {
                                        // Just continue
                                }
                        }
                        pos++;
                        length++;
                        newsrc += depth;
                        org++;
                }
                newsrc += offset;
        }
        if (isInDif) {
                *lastCtrl = (unsigned int)((DIFCTRL << 24) | length);
        //      len += length;
        }
        else {
                *lastCtrl = (unsigned int)((DATACTRL << 24) | length);
        //      len += length;
        }
        dstlen = pos * 4;


/*      pos = 0;
        int totallen = 0;
        int ctrl;
        while (pos < (dstlen/4)) {
                ctrl = (newdst[pos] >> 24);
                len = (newdst[pos] & 0xFFFFFF);
                pos++;
                if (ctrl == 1) {
                        totallen += len;
                        printf("Data[%d] (%d) ", len, totallen);
                //      for (int k=0; k<len; k++)
                //              printf("%c ", (char) newdst[pos+k]);
                        pos += len;
                }
                else if (ctrl == 2) {
                        totallen += len;
                        printf("RLE[%d] (%d) ", len, totallen);
                        pos++;
                }
                else if (ctrl == 3) {
                        totallen += len;
                        printf("RLE[%d] (%d) ", len, totallen);
                        // pos++;
                }
                else {
                        printf("Wrong CTRL: %d ", ctrl);
                        pos++;
                }
        }*/

        return dst;
}

char* Bitmap::differenceBitmapFileDataRunLength(char* orig, char* src, int width, int height, int depth, long &dstlen) {

        char* dst = new char[width*height*4 + 100];

        int c;
        int padding = 4 - ((width*depth)%4);
        if (padding == 4) padding = 0;
        int lineWidth = width*depth + padding;
        int offset = padding - (2*lineWidth);

        unsigned char* newsrc = (unsigned char*) (src + ((height-1) * lineWidth));
        unsigned int* newdst = (unsigned int*) dst;
        unsigned int* org = (unsigned int*) orig;
        unsigned int* lastCtrl = newdst;
        
        int pos = 1;
        int length = 0;
        int dlength = 0;

        bool isInRL = false;
        bool isInDif = false;

//      int len = 0;
        for (int l = 0; l < height; l++)
        {
                for (c = 0; c < width; c++) {
                        newdst[pos] = ((unsigned int)((newsrc[0] << 16) | (newsrc[1] << 8) | (newsrc[2] << 0)));

                        if (isInDif) {
                                if (*org == newdst[pos]) {
                                        // Continue Dif
                                        pos--;
                                }
                                else {
                                        // End Dif
                                        *lastCtrl = (unsigned int)((DIFCTRL << 24) | length);
                                        //len += length;
                                        length = 0;
                                        lastCtrl++;
                                        pos++;
                                        newdst[pos] = newdst[pos-1];
                                        isInDif = false;
                                }
                        }
                        else if (isInRL) {
                                if (newdst[pos-1] == newdst[pos]) {
                                        // Continue RL
                                        pos--;
                                }
                                else {
                                        // End RL
                                        *lastCtrl = (unsigned int)((RLECTRL << 24) | length);
                                        //len += length;
                                        length = 0;
                                        lastCtrl += 2;
                                        pos++;
                                        newdst[pos] = newdst[pos-1];
                                        isInRL = false;
                                }
                        }
                        else {
                                if (*org == newdst[pos]) {
                                        if (pos == 1) {
                                                pos--;
                                        }
                                        else {
                                                // Close previous series
                                                *lastCtrl = (unsigned int)((DATACTRL << 24) | (length));
                                        //      len += length;
                                                lastCtrl += length + 1;
                                                length = 0;
                                                // pos--;
                                        }
                                        isInDif = true;
                                }
                                else if ( (length > 1) && (newdst[pos-2] == newdst[pos-1]) && (newdst[pos-1] == newdst[pos]) ) {
                                        if (length == 2) {
                                                // No data series, switch to RL
                                                pos -= 2;
                                        }
                                        else {
                                                // Close previous series
                                                *lastCtrl = (unsigned int)((DATACTRL << 24) | (length - 2));
                                        //      len += length - 2;
                                                lastCtrl += length - 1;
                                                length = 2;
                                                pos--;
                                        }
                                        isInRL = true;
                                }
                                else {
                                        // Just continue
                                }
                        }
                        pos++;
                        length++;
                        org++;
                        newsrc += depth;
                }
                newsrc += offset;
        }
        if (isInDif) {
                *lastCtrl = (unsigned int)((DIFCTRL << 24) | length);
        //      len += length;
        }
        else if (isInRL) {
                *lastCtrl = (unsigned int)((RLECTRL << 24) | length);
        //      len += length;
        }
        else {
                *lastCtrl = (unsigned int)((DATACTRL << 24) | length);
        //      len += length;
        }
        dstlen = pos * 4;

        return dst;
}

BitmapUpdate* Bitmap::getCompressedUpdate(bool destructive) const {
        if (!destructive)
                return runLengthEncode();
        else
                return runLengthDestructiveEncode();
}


BitmapUpdate* Bitmap::operator -( const Bitmap &bitmap ) const {

        if ( (this->width != bitmap.width) || (this->height != bitmap.height) )
                return NULL;

        int byteWidth = width*4;

        char* dst = new char[width*height*4 + 100];

        unsigned int* newsrc = (unsigned int*) this->data;
        unsigned int* newdst = (unsigned int*) dst;
        unsigned int* org = (unsigned int*) bitmap.data;
        unsigned int* lastCtrl = newdst;
        
        int pos = 1;
//      int pos = 0;
        int length = 0;

        bool isInRL = false;
        bool isInDif = false;

        int maxpos = (int)(width*height*0.9);
        unsigned int* endsrc = newsrc + (width*height);
        while ((newsrc < endsrc) && (pos <= maxpos)) {

                newdst[pos] = *newsrc;

                if (isInDif) {
                        if (*org == newdst[pos]) {
                                // Continue Dif
                                pos--;
                        }
                        else {
                                // End Dif
                                *lastCtrl = (unsigned int)((DIFCTRL << 24) | length);
                                //len += length;
                                length = 0;
                                lastCtrl++;
                                pos++;
                                newdst[pos] = newdst[pos-1];
                                isInDif = false;
                        }
                }
                else if (isInRL) {
                        if (newdst[pos-1] == newdst[pos]) {
                                // Continue RL
                                pos--;
                        }
                        else {
                                // End RL
                                *lastCtrl = (unsigned int)((RLECTRL << 24) | length);
                                //len += length;
                                length = 0;
                                lastCtrl += 2;
                                pos++;
                                newdst[pos] = newdst[pos-1];
                                isInRL = false;
                        }
                }
                else {
                        if (*org == newdst[pos]) {
                                if (pos == 1) {
                                        pos--;
                                }
                                else {
                                        // Close previous series
                                        *lastCtrl = (unsigned int)((DATACTRL << 24) | (length));
                                //      len += length;
                                        lastCtrl += length + 1;
                                        length = 0;
                                        // pos--;
                                }
                                isInDif = true;
                        }
                        else if ( (length > 1) && (newdst[pos-2] == newdst[pos-1]) && (newdst[pos-1] == newdst[pos]) ) {
                                if (length == 2) {
                                        // No data series, switch to RL
                                        pos -= 2;
                                }
                                else {
                                        // Close previous series
                                        *lastCtrl = (unsigned int)((DATACTRL << 24) | (length - 2));
                                //      len += length - 2;
                                        lastCtrl += length - 1;
                                        length = 2;
                                        pos--;
                                }
                                isInRL = true;
                        }
                        else {
                                // Just continue
                        }
                }
                pos++;
                length++;
                org++;
                newsrc++;
        }
        
        // Forget it, difference is too big anyway...
        if (pos > maxpos) {
                delete [] dst;
                return this->getCompressedUpdate(false);
        }


        if (isInDif) {
                if (pos <= 1) {
                        delete [] dst;
                        return NULL;
                }
                *lastCtrl = (unsigned int)((DIFCTRL << 24) | length);
        //      len += length;
        }
        else if (isInRL) {
                *lastCtrl = (unsigned int)((RLECTRL << 24) | length);
        //      len += length;
        }
        else {
                *lastCtrl = (unsigned int)((DATACTRL << 24) | length);
        //      len += length;
        }

        BitmapUpdate* update = new BitmapUpdate(width, height);
        update->giveData(dst, pos * 4);
        update->setUpdateType("DifRunLength");
        return update;
}





BitmapUpdate* Bitmap::runLengthEncode() const {

        if ( (this->width <= 0) || (this->height <= 0) )
                return NULL;

        int byteWidth = width*4;

        char* dst = new char[width*height*4 + 100];

        unsigned int* newsrc = (unsigned int*) this->data;
        unsigned int* newdst = (unsigned int*) dst;
        unsigned int* lastCtrl = newdst;
        
        int pos = 1;
//      int pos = 0;
        int length = 0;

        bool isInRL = false;

        unsigned int* endsrc = newsrc + (width*height);

        while (newsrc < endsrc) {
                newdst[pos] = *newsrc;

                if (isInRL) {
                        if (newdst[pos-1] == newdst[pos]) {
                                // Continue RL
                                pos--;
                        }
                        else {
                                // End RL
                                *lastCtrl = (unsigned int)((RLECTRL << 24) | length);
                                //len += length;
                                length = 0;
                                lastCtrl += 2;
                                pos++;
                                newdst[pos] = newdst[pos-1];
                                isInRL = false;
                        }
                }
                else {
                        if ( (length > 1) && (newdst[pos-2] == newdst[pos-1]) && (newdst[pos-1] == newdst[pos]) ) {
                                if (length == 2) {
                                        // No data series, switch to RL
                                        pos -= 2;
                                }
                                else {
                                        // Close previous series
                                        *lastCtrl = (unsigned int)((DATACTRL << 24) | (length - 2));
                                //      len += length - 2;
                                        lastCtrl += length - 1;
                                        length = 2;
                                        pos--;
                                }
                                isInRL = true;
                        }
                        else {
                                // Just continue
                        }
                }
                pos++;
                length++;
                newsrc++;
        }

        if (isInRL) {
                *lastCtrl = (unsigned int)((RLECTRL << 24) | length);
        //      len += length;
        }
        else {
                *lastCtrl = (unsigned int)((DATACTRL << 24) | length);
        //      len += length;
        }

        BitmapUpdate* update = new BitmapUpdate(width, height);
        update->giveData(dst, pos * 4);
        update->setUpdateType("RunLength");
        return update;
}

BitmapUpdate* Bitmap::runLengthDestructiveEncode() const {

        if ( (this->width <= 0) || (this->height <= 0) )
                return NULL;

        int byteWidth = width*4;

        char* dst = new char[width*height*2 + 100];

        unsigned int* newsrc = (unsigned int*) this->data;
        unsigned int* newdst = (unsigned int*) dst;
        unsigned int* lastCtrl = newdst;
        
        int pos = 1;
//      int pos = 0;
        int length = 0;

        bool isInRL = false;

        unsigned int* endsrc = newsrc + (width*height);
        unsigned int* endsrc1 = endsrc - 2;
        
        while (newsrc < endsrc1) {
                newdst[pos] = GET_DRGB_FROM_2RGBS(*newsrc,*(newsrc+1));
                newsrc+=2;
                if (isInRL) {
                        if (newdst[pos-1] == newdst[pos]) {
                                // Continue RL
                                pos--;
                        }
                        else {
                                // End RL
                                *lastCtrl = (unsigned int)((RLECTRL << 24) | length);
                                //len += length;
                                length = 0;
                                lastCtrl += 2;
                                pos++;
                                newdst[pos] = newdst[pos-1];
                                isInRL = false;
                        }
                }
                else {
                        if ( (length > 1) && (newdst[pos-2] == newdst[pos-1]) && (newdst[pos-1] == newdst[pos]) ) {
                                if (length == 2) {
                                        // No data series, switch to RL
                                        pos -= 2;
                                }
                                else {
                                        // Close previous series
                                        *lastCtrl = (unsigned int)((DATACTRL << 24) | (length - 2));
                                //      len += length - 2;
                                        lastCtrl += length - 1;
                                        length = 2;
                                        pos--;
                                }
                                isInRL = true;
                        }
                        else {
                                // Just continue
                        }
                }
                pos++;
                length++;
                // newsrc+=2;
        }
        if (endsrc-newsrc == 2)
                newdst[pos] = GET_DRGB_FROM_2RGBS(*newsrc,*(newsrc+1));
        else
                newdst[pos] = GET_DRGB_FROM_2RGBS(*newsrc,0);

        if (isInRL) {
                if (newdst[pos-1] == newdst[pos]) {
                        // Continue RL
                        pos--;
                }
                else {
                        // End RL
                        *lastCtrl = (unsigned int)((RLECTRL << 24) | length);
                        //len += length;
                        length = 0;
                        lastCtrl += 2;
                        pos++;
                        newdst[pos] = newdst[pos-1];
                        isInRL = false;
                }
        }
        else {
                if ( (length > 1) && (newdst[pos-2] == newdst[pos-1]) && (newdst[pos-1] == newdst[pos]) ) {
                        if (length == 2) {
                                // No data series, switch to RL
                                pos -= 2;
                        }
                        else {
                                // Close previous series
                                *lastCtrl = (unsigned int)((DATACTRL << 24) | (length - 2));
                        //      len += length - 2;
                                lastCtrl += length - 1;
                                length = 2;
                                pos--;
                        }
                        isInRL = true;
                }
                else {
                        // Just continue
                }
        }
        pos++;
        length++;
        newsrc+=2;

        if (isInRL) {
                *lastCtrl = (unsigned int)((RLECTRL << 24) | length);
        //      len += length;
        }
        else {
                *lastCtrl = (unsigned int)((DATACTRL << 24) | length);
        //      len += length;
        }

        BitmapUpdate* update = new BitmapUpdate(width, height);
        update->giveData(dst, pos * 4);
        update->setUpdateType("RL16");
        return update;
}



char* ImageResizeDown66(char* bytesource, int &cols, int &rows)
{

        // This algorithm was written for single byte images,
        // we need this for 4 byte images, or integers

        char* bytedest = new char[cols*rows*4];

        unsigned int* source = (unsigned int*) bytesource;
        unsigned int* dest = (unsigned int*) bytedest;

        // Pointer arrangment
        //       p q r    ->   a b
        //       s t u         c d
        //       v w x

        unsigned int *p;
        unsigned int *q;
        unsigned int *r;
        unsigned int *s;
        unsigned int *t;
        unsigned int *u;
        unsigned int *v;
        unsigned int *w;
        unsigned int *x;
        unsigned int *a;
        unsigned int *b;
        unsigned int *c;
        unsigned int *d;

        unsigned int** shrows = new unsigned int*[rows];

        shrows[0] = source;
        for (int n=1; n<rows; n++) {
                shrows[n] = shrows[n-1] + cols;
        }

        q = shrows[0] + 1;
        s = shrows[1];
        t = s + 1;
        u = t + 1;
        w = shrows[2] + 1;

        // Smooth - skip first and last rows, first and last cols
        // This is a bit of a cheat since the left pixel of each group
        // is smoothed with an already-smoothed pixel
        // ------------------------------------------------------

        /*        for(int i = 1; i < rows-1; i++)
                        {
                        q = shrows[i-1] + 1;
                        s = shrows[i];
                        t = s + 1;
                        u = t + 1;
                        w = shrows[i+1] + 1;

                        for(int j = 0; j < cols; j++, q++, s++, t++, u++, w++)
                                        *t = (AGPIXEL)(((int)(*q) + (int)(*w) + 4 * (int)(*t)) / 6);
                        }
        */

        // Now for the resizing
        // --------------------

        int newcols = (int)((2.0*cols)/3.0);
        int newrows = (int)((2.0*rows)/3.0);

        if (newcols != (2.0*cols/3.0))
                newcols++;
        if (newrows != (2.0*cols/3.0))
                newrows++;

        unsigned int *r1 = dest;
        unsigned int *r2 = dest + newcols;

        //        printf("RESIZE\n Rows: %-3d->%-3d\n Cols %-3d->%-3d\n", rows, newrows, cols, newcols);

        int j;
        for(int i = 0, k = 0; i < rows; i += 3, k += 2) {
                p = shrows[i];
                q = p+1;
                r = q+1;
                if (rows - i > 2)
                        s = shrows[i+1];
                else
                        s = p;
                t = s+1;
                u = t+1;
                if (rows - i > 2)
                        v = shrows[i+2];
                else
                        v = p;
                w = v+1;
                x = w+1;

                // r1 = PIXEL[k];
                r1 = dest + (newcols * k);
                // r2 = r1+ cols64;
                r2 = r1 + newcols;

                a = r1;
                b = a+1;
                if (newrows - k < 1)
                        c = a;
                else
                        c = r2;
                d = c+1;

                for(j = 0; j < cols-3; j += 3) {
                        *a = GET_RGB_FROM_RGBA(*p);
                        *b = (((unsigned int)((1+(double)GET_R_FROM_RGBA(*q) + (double)GET_R_FROM_RGBA(*r))/2)) << 0) +
                                 (((unsigned int)((1+(double)GET_G_FROM_RGBA(*q) + (double)GET_G_FROM_RGBA(*r))/2)) << 8) +
                                 (((unsigned int)((1+(double)GET_B_FROM_RGBA(*q) + (double)GET_B_FROM_RGBA(*r))/2)) << 16);
                        *c = (((unsigned int)((1+(double)GET_R_FROM_RGBA(*s) + (double)GET_R_FROM_RGBA(*v))/2)) << 0) +
                                 (((unsigned int)((1+(double)GET_G_FROM_RGBA(*s) + (double)GET_G_FROM_RGBA(*v))/2)) << 8) +
                                 (((unsigned int)((1+(double)GET_B_FROM_RGBA(*s) + (double)GET_B_FROM_RGBA(*v))/2)) << 16);
                        *d = (((unsigned int)((1+(double)GET_R_FROM_RGBA(*t) + (double)GET_R_FROM_RGBA(*u) + (double)GET_R_FROM_RGBA(*w) + (double)GET_R_FROM_RGBA(*x))/4)) << 0) +
                                 (((unsigned int)((1+(double)GET_G_FROM_RGBA(*t) + (double)GET_G_FROM_RGBA(*u) + (double)GET_G_FROM_RGBA(*w) + (double)GET_G_FROM_RGBA(*x))/4)) << 8) +
                                 (((unsigned int)((1+(double)GET_B_FROM_RGBA(*t) + (double)GET_B_FROM_RGBA(*u) + (double)GET_B_FROM_RGBA(*w) + (double)GET_B_FROM_RGBA(*x))/4)) << 16);

                        p += 3;
                        q += 3;
                        r += 3;
                        s += 3;
                        t += 3;
                        u += 3;
                        v += 3;
                        w += 3;
                        x += 3;
                        a += 2;
                        b += 2;
                        c += 2;
                        d += 2;
                }
                if (cols - j > 0)
                        *a = GET_RGB_FROM_RGBA(*p);
                else
                        *a = *(a-2);
                if (cols - j > 1)
                        *b = (((unsigned int)((1+(double)GET_R_FROM_RGBA(*q) + (double)GET_R_FROM_RGBA(*r))/2)) << 0) +
                                        (((unsigned int)((1+(double)GET_G_FROM_RGBA(*q) + (double)GET_G_FROM_RGBA(*r))/2)) << 8) +
                                        (((unsigned int)((1+(double)GET_B_FROM_RGBA(*q) + (double)GET_B_FROM_RGBA(*r))/2)) << 16);
                else
                        *b = *(b-2);
                if (cols - j > 2)
                        *c = (((unsigned int)((1+(double)GET_R_FROM_RGBA(*s) + (double)GET_R_FROM_RGBA(*v))/2)) << 0) +
                                        (((unsigned int)((1+(double)GET_G_FROM_RGBA(*s) + (double)GET_G_FROM_RGBA(*v))/2)) << 8) +
                                        (((unsigned int)((1+(double)GET_B_FROM_RGBA(*s) + (double)GET_B_FROM_RGBA(*v))/2)) << 16);
                else
                        *c = *(c-2);
                if (cols - j > 3)
                        *d = (((unsigned int)((1+(double)GET_R_FROM_RGBA(*t) + (double)GET_R_FROM_RGBA(*u) + (double)GET_R_FROM_RGBA(*w) + (double)GET_R_FROM_RGBA(*x))/4)) << 0) +
                                        (((unsigned int)((1+(double)GET_G_FROM_RGBA(*t) + (double)GET_G_FROM_RGBA(*u) + (double)GET_G_FROM_RGBA(*w) + (double)GET_G_FROM_RGBA(*x))/4)) << 8) +
                                        (((unsigned int)((1+(double)GET_B_FROM_RGBA(*t) + (double)GET_B_FROM_RGBA(*u) + (double)GET_B_FROM_RGBA(*w) + (double)GET_B_FROM_RGBA(*x))/4)) << 16);
                else
                        *d = *(d-2);

        }
//      printf("Resize done");
        delete [] shrows;
        cols = newcols;
        rows = newrows;
        return bytedest;
}

char* ImageResizeUp66(char* bytesource, int &cols, int &rows) {

        // This algorithm was written for single byte images,
        // we need this for 4 byte images, or integers

        // Pointer arrangment
        //       p q r    ->   a b
        //       s t u         c d
        //       v w x

        unsigned int *p;
        unsigned int *q;
        unsigned int *r;
        unsigned int *s;
        unsigned int *t;
        unsigned int *u;
        unsigned int *v;
        unsigned int *w;
        unsigned int *x;
        unsigned int *a;
        unsigned int *b;
        unsigned int *c;
        unsigned int *d;

        int newcols = (int)((3.0*(double)cols)/2.0);
        int newrows = (int)((3.0*(double)rows)/2.0);
        if ((double)newcols != (3.0*cols)/2.0)
                newcols++;
        if ((double)newrows != (3.0*rows)/2.0)
                newrows++;

        char* bytedest = new char[newcols*newrows*4];
        unsigned int* source = (unsigned int*) bytesource;
        unsigned int* dest = (unsigned int*) bytedest;

        unsigned int** dhrows = new unsigned int*[newrows];

        dhrows[0] = dest;
        for (int n=1; n<newrows; n++) {
                dhrows[n] = dhrows[n-1] + newcols;
        }

        q = dhrows[0] + 1;
        s = dhrows[1];
        t = s + 1;
        u = t + 1;
        w = dhrows[2] + 1;

        // Now for the resizing
        // --------------------


        unsigned int *r1 = source;
        unsigned int *r2 = source + cols;

        //        printf("RESIZE\n Rows: %-3d->%-3d\n Cols %-3d->%-3d\n", rows, newrows, cols, newcols);

        int realrows = newrows-3;
        int realcols = newcols-3;
//      int ii, kk, jj;
        int i, j, k;
        for(i = 0, k = 0; i <= realrows; i += 3, k += 2) {
                p = dhrows[i];
                q = p+1;
                r = q+1;
                s = dhrows[i+1];
                t = s+1;
                u = t+1;
                v = dhrows[i+2];
                w = v+1;
                x = w+1;

                // r1 = PIXEL[k];
                r1 = source + (cols * k);
                // r2 = r1+ cols64;
                r2 = r1 + cols;

                a = r1;
                b = a+1;
                c = r2;
                d = c+1;

                for(j = 0; j <= realcols; j += 3) {
                        *p = GET_RGB_FROM_RGBA(*a);
                        *q = *r = GET_RGB_FROM_RGBA(*b);
                        *s = *v = GET_RGB_FROM_RGBA(*c);
                        *t = *u = *w = *x = GET_RGB_FROM_RGBA(*d);;
                        p += 3;
                        q += 3;
                        r += 3;
                        s += 3;
                        t += 3;
                        u += 3;
                        v += 3;
                        w += 3;
                        x += 3;
                        a += 2;
                        b += 2;
                        c += 2;
                        d += 2;
                }
                if (newcols - j == 2) {
                        *p = GET_RGB_FROM_RGBA(*a);
                        *q= GET_RGB_FROM_RGBA(*b);
                        *s = *v = GET_RGB_FROM_RGBA(*c);
                        *t= *w = GET_RGB_FROM_RGBA(*d);;
                }
                else if (newcols - j == 1) {
                        *p = GET_RGB_FROM_RGBA(*a);
                        *s = *v = GET_RGB_FROM_RGBA(*c);
                }
        }
        if (newrows - i == 2) {
                p = dhrows[i];
                q = p+1;
                r = q+1;
                s = dhrows[i+1];
                t = s+1;
                u = t+1;

                // r1 = PIXEL[k];
                r1 = source + (cols * k);
                // r2 = r1+ cols64;
                r2 = r1 + cols;

                a = r1;
                b = a+1;
                c = r2;
                d = c+1;

                for(j = 0; j <= realcols; j += 3) {
                        *p = GET_RGB_FROM_RGBA(*a);
                        *q = *r = GET_RGB_FROM_RGBA(*b);
                        *s = GET_RGB_FROM_RGBA(*c);
                        *t = *u = GET_RGB_FROM_RGBA(*d);;
                        p += 3;
                        q += 3;
                        r += 3;
                        s += 3;
                        t += 3;
                        u += 3;
                        v += 3;
                        w += 3;
                        x += 3;
                        a += 2;
                        b += 2;
                        c += 2;
                        d += 2;
                }
                if (newcols - j == 2) {
                        *p = GET_RGB_FROM_RGBA(*a);
                        *q= GET_RGB_FROM_RGBA(*b);
                        *s =GET_RGB_FROM_RGBA(*c);
                        *t= GET_RGB_FROM_RGBA(*d);;
                }
                else if (newcols - j == 1) {
                        *p = GET_RGB_FROM_RGBA(*a);
                        *s = GET_RGB_FROM_RGBA(*c);
                }
        }
        else if (newrows - i == 1) {
                p = dhrows[i];
                q = p+1;
                r = q+1;

                // r1 = PIXEL[k];
                r1 = source + (cols * k);
                // r2 = r1+ cols64;
                r2 = r1 + cols;

                a = r1;
                b = a+1;
                c = r2;
                d = c+1;

                for(j = 0; j <= realcols; j += 3) {
                        *p = GET_RGB_FROM_RGBA(*a);
                        *q = *r = GET_RGB_FROM_RGBA(*b);
                        p += 3;
                        q += 3;
                        r += 3;
                        s += 3;
                        t += 3;
                        u += 3;
                        v += 3;
                        w += 3;
                        x += 3;
                        a += 2;
                        b += 2;
                        c += 2;
                        d += 2;
                }
                if (newcols - j == 2) {
                        *p = GET_RGB_FROM_RGBA(*a);
                        *q= GET_RGB_FROM_RGBA(*b);
                }
                else if (newcols - j == 1) {
                        *p = GET_RGB_FROM_RGBA(*a);
                }
        }
//      printf("Resize done");
        delete [] dhrows;
        cols = newcols;
        rows = newrows;
        return bytedest;
}

char* ImageResizeDown(char* bytesource, int &cols, int &rows, int factor) {
        if (factor <= 0) {
                return NULL;
        }
        int factor2 = factor*factor;

        int newcols = (int)((double)cols/factor);
        int newrows = (int)((double)rows/factor);
        if ((double)newcols != ((double)cols/factor))
                newcols++;
        if ((double)newrows != ((double)rows/factor))
                newrows++;

        char* bytedest = new char[newcols*newrows*4];

        if (factor == 1) {
                memcpy(bytedest, bytesource, cols*rows*4);
                return bytedest;
        }

        unsigned int* source = (unsigned int*) bytesource;
        unsigned int* dest = (unsigned int*) bytedest;

        int n, m;
//      unsigned int* destPixel = dest;
        unsigned int* srcStartPixel = source;
//      unsigned int* srcPixel;
        unsigned char* srcPixelByte;

        double r;
        double g;
        double b;
        int step = (cols - factor)*4;
        int linestep = (factor-1)*cols;

        int rowmax = rows-factor;
        int colmax = cols-factor;
//      int rowmax = rows;
//      int colmax = cols;

        int factorX, factorY;

        double dfactor2 = 1.0/((double)factor2);

        unsigned char* destPixelByte = (unsigned char*) dest;
        // Take a square of f*f pixels and average to produce 1 pixel
        for (int y=0; y<=rowmax; y+=factor) {
                factorY = clmin(factor, rows-y);
                for (int x=0; x<=colmax; x+=factor) {
                        factorX = clmin(factor, cols-x);
//                      factorX = factor;
                        r = g = b = 0;
                        factor2 = factorY*factorX;
                        srcPixelByte = (unsigned char*)srcStartPixel;
                        for (n=0; n<factorY; n++) {
                                for (m=0; m<factorX; m++) {
                                        r += *srcPixelByte++;
                                        g += *srcPixelByte++;
                                        b += *srcPixelByte++;
                                        srcPixelByte++;
                                }
                                srcPixelByte += step;
                        }
                        *destPixelByte++ = (unsigned char) (r*dfactor2);
                        *destPixelByte++ = (unsigned char) (g*dfactor2);
                        *destPixelByte++ = (unsigned char) (b*dfactor2);
                        *destPixelByte++ = 0;
                //      ((unsigned char*)destPixel)[0] = (int) r/factor2;
                //      ((unsigned char*)destPixel)[1] = (int) g/factor2;
                //      ((unsigned char*)destPixel)[2] = (int) b/factor2;
                        // *destPixel = (int) val/(factor*factor);
                        srcStartPixel += factorX;
                }
                srcStartPixel += linestep;
/*              if ( (x-colmax > 0) && (x-colmax <= (factor/2)) ) {
                        *destPixelByte++ = (unsigned char) (r/factor2);
                        *destPixelByte++ = (unsigned char) (g/factor2);
                        *destPixelByte++ = (unsigned char) (b/factor2);
                        *destPixelByte++ = 0;
                }*/
        }
        cols = newcols;
        rows = newrows;
        return bytedest;
}

char* ImageResizeUp(char* bytesource, int &cols, int &rows, int factor) {

        if (factor <= 0) {
                return NULL;
        }
        int factor2 = factor*factor;
        int newcols = cols*factor;
        int newrows = rows*factor;

        char* bytedest = new char[newcols*newrows*4];
        if (factor == 1) {
                memcpy(bytedest, bytesource, cols*rows*4);
                return bytedest;
        }

        unsigned int* source = (unsigned int*) bytesource;
        unsigned int* dest = (unsigned int*) bytedest;

        int destCols = cols*factor;
        int n, m, pixel;
        unsigned int* destStartPixel = dest;
        unsigned int* destPixel;
        unsigned int* srcPixel = source;
        int step = destCols - factor;
        int linestep = (factor-1)*destCols;
        // int linestep = factor*cols;

        // Take a pixel and make it a square of f*f pixels
        for (int x=0; x<rows; x++) {
                for (int y=0; y<cols; y++) {
                        destPixel = destStartPixel;
                        pixel = GET_RGB_FROM_RGBA(*srcPixel++);
                        for (n=0; n<factor; n++) {
                                for (m=0; m<factor; m++) {
                                        *destPixel++ = pixel;
                                }
                                destPixel += step;
                        }
                        destStartPixel += factor;
                }
                destStartPixel += linestep;
        }
        // Take a square of f*f pixels and average to produce 1 pixel
        cols = newcols;
        rows = newrows;
        return bytedest;
}









} // namespace cmlabs

---