root/trunk/BMP.cpp

///////////////////////////////////////////////////////////
//                        TexGen                         //
//          утилита для подготовки текстур рельефа       //
//               для игры Проклятые Земли                //
//           Copyright (C) 2007-2008 Gipat Group         //
//              Распространяется на условиях             //
//    Gipat Group's opened EI-editor-utility license     //
//                      версии 1.0                       //
//                                                       //
//                  www.gipatgroup.org                   //
///////////////////////////////////////////////////////////

//К работе над данным файлом приложили руки, ноги.... короче аффтары:
// 1) Снайпер (sniper-rifle@rambler.ru)

////////////////////////////////////////////////////////////////////////

#include <vcl.h>
#include "BMP.h"
//------------------------------------------------
CBitMap::CBitMap(int XSize, int YSize, ColorRGB Clr)
//Дефолтный конструктор битмапы. Создаёт картинку XSize*YSize, и заливает её цветом Clr.
{
  H = YSize;
  W = XSize;
  DeltaZero=W%4;
  Inited = true;
  Buffer = new byte[PicWeight()]; //Создаём в дин. памяти кусок под картинку
  int Cursor = 0;   //Чтоб не гемориться с формулами, просто сдвигаем курсор на 1.
  for(int i=0;i<H;i++)
  {
    for(int j=0;j<W;j++)
    {
      memcpy(Buffer + Cursor++,&Clr.Blue,1);
      memcpy(Buffer + Cursor++,&Clr.Green,1);
      memcpy(Buffer + Cursor++,&Clr.Red,1);
    }
    Cursor += DeltaZero;
  }
}
//------------------------------------------------
void CBitMap::Save(AnsiString FName)
{
  if(Inited)
  {
//    FILE *f;
    int Handler;
    AnsiString Buf = "BM****####****[SZ][WI][HE]01240000[SI]0000000000000000";
    int BufSize = PicWeight(), BL = 54,BL1=BL+BufSize, Zero=0;
    short int A1=1, A2=24,XYPM = 2834;

    Buf.SetLength(BL + BufSize);


    memcpy(&Buf[3],&BL1,4);
    memcpy(&Buf[11],&BL,4);
    memcpy(&Buf[7],&Zero,4);

    BL = 40;
    memcpy(&Buf[15],&BL,4);
    memcpy(&Buf[19],&W,4);
    memcpy(&Buf[23],&H,4);
   // BL = 1;
    memcpy(&Buf[27],&A1,2);
   // BL = 24;
    memcpy(&Buf[29],&A2,2);
    memcpy(&Buf[31],&Zero,4);
    memcpy(&Buf[35],&BufSize,4);
    memcpy(&Buf[39],&XYPM,4);
    memcpy(&Buf[43],&XYPM,4);
    memcpy(&Buf[47],&Zero,4);
    memcpy(&Buf[51],&Zero,4);

    memcpy(&Buf[55],Buffer,BufSize);
  //----------
    Handler = FileCreate(FName,fmOpenWrite);
    if(Handler)
    {
      FileWrite(Handler,&Buf[1],Buf.Length());
      FileClose(Handler);
    }
//    f = fopen(FName.c_str(),"w");
//    fwrite(&Buf[1],Buf.Length(),1,f);
//    fclose(f);
  }
}
//---- --------------------------------------------
CBitMap::CBitMap(AnsiString FName)
{
  //-------------------------
  Inited = false;
  //FILE *f;
  //f=fopen(FName.c_str(),"r");
  //fseek(f,0,SEEK_END);
  int Hnd=FileOpen(FName,fmOpenRead);
  if(Hnd > 0)
  {
    int L = FileSeek(Hnd,0,SEEK_END);
    int bfOffBits;
    //fseek(f,0,SEEK_SET);
    FileSeek(Hnd,0,SEEK_SET);
    byte *BUF=new byte[L];
    FileRead(Hnd,BUF,L);
    FileClose(Hnd);
    //fread(BUF,L,1,f);
    //fclose(f);
    //--------------------------
    //Загрузили, теперь запихиваем данные в объект класса CBitMap
    AnsiString TMP="**";
    memcpy(&TMP[1],BUF,2);
    if(TMP=="BM")
    {
      memcpy(&bfOffBits,BUF+10,4);//Оффсет типа %)
      memcpy(&W,BUF+18,4);//Width
      memcpy(&H,BUF+22,4);//Height
      memcpy(&D,BUF+28,2);//Depth
      DeltaZero = W%4;//Подбираем кол-во нулей...
      int PW = PicWeight();//, TEST = L - PW;
      if(D==24)
      {
        int C;
        memcpy(&C,BUF+30,4);
        if(C==0) //Compression
        {
          memcpy(&RealSize,BUF+34,4);

          Buffer = new byte[PW];
          memcpy(Buffer,BUF+bfOffBits,PW);
          Inited = true;
        }
        else
        {
          ShowMessage("Обнаружено сжатие. Сжатие не поддерживается!");
        }
      }
      else
      {
        ShowMessage("Файл не является 24-битным точечным рисунком:\r\n"+FName+"\r\nКласс поддерживает только 24-битные точечные рисунки!");
      }
    }
    else
    {
      ShowMessage("Файл не является точечным рисунком:\r\n"+FName+"\r\nПервые 2 байта должны быть равны \"BM\", а остальное я не проверял и не думаю проверять...");
    }
    delete [] BUF;
  }
  else
  {
    ShowMessage("Не удалось открыть файл "+FName+"!");
  }
}

CBitMap::ColorRGB CBitMap::GetPixel(int X, int Y)
{
  bool Match = (X >= 0)&&(X<W)&&(Y>=0)&&(Y<H)&&Inited;
  ColorRGB Rez;
  if(Match)
  {
    memcpy(&Rez.Blue, Buffer+Y*(W*3+DeltaZero)+X*3+0,1);
    memcpy(&Rez.Green,Buffer+Y*(W*3+DeltaZero)+X*3+1,1);
    memcpy(&Rez.Red,  Buffer+Y*(W*3+DeltaZero)+X*3+2,1);
  }
  else
  {
    Rez.Red = Rez.Green = Rez.Blue = 0;
  }
  return Rez;
}

void CBitMap::SetPixel(int X, int Y, ColorRGB Clr)
{
  bool Match = (X >= 0)&&(X<W)&&(Y>=0)&&(Y<H);
  if(Match)
  {
    memcpy(Buffer+Y*(W*3+DeltaZero)+X*3+0,&Clr.Blue ,1);
    memcpy(Buffer+Y*(W*3+DeltaZero)+X*3+1,&Clr.Green,1);
    memcpy(Buffer+Y*(W*3+DeltaZero)+X*3+2,&Clr.Red  ,1);
  }
}

void CBitMap::Paste(int X, int Y, CBitMap *BMP)
{
  bool Match = (X<W)&&(Y<H)&&(X+BMP->W >= 0)&&(Y+BMP->H >= 0)&&Inited&&(BMP->Inited);
  if(Match)
  {
    // Координаты по оси X
    int Xdest,Xsrc,Sdest,Ssrc;
    //Определить, в какую точку 1-й картинки Xdest надо копировать строку
    Xdest = (X>=0)?X:0;
    //Определить, с какой точки 2-й картинки Xsrc надо брать информацию
    Xsrc = (X>=0)?0:-X;
    //Sdest - это длина строки, которая использована в первой картинке
    Sdest = W-Xdest;
    //Ssrc - это длина строки, которая берётся из второй картинки
    Ssrc = BMP->W - Xsrc;
    if(Ssrc>Sdest)Ssrc=Sdest;// На случай, если пихаемый кусок больше места для него.

    //Координаты по оси Y
    int Ydest,Ysrc, Rdest, Rsrc;
    //Определить, с какой строки "картинки назначения" начинать вставку
    Ydest = (Y>=0)?Y:0;
    //С какой строки второй картинки начинать копирование данных
    Ysrc = (Y>=0)?0:-Y;
    //Rdest - диапазон строк, свободных для вставки в них
    Rdest = H-Ydest;
    //Rsrc - диапазон строк, доступных для чтения оттуда
    Rsrc = BMP->H - Ysrc;
    if(Rsrc>Rdest)Rsrc=Rdest;//Опять же, чтоб без переполнений...

    //Сам процесс копирования:
    byte *TempStr = new byte[Ssrc*3];//Кусок памяти под копируемую строку.
    for(int i=0;i<Rsrc;i++)
    {
      memcpy(TempStr,BMP->Buffer+(Ysrc+i)*(BMP->W*3+BMP->DeltaZero)+Xsrc*3,Ssrc*3); //Это строка номер i
      memcpy(Buffer+(Ydest+i)*(W*3+DeltaZero)+Xdest*3,TempStr,Ssrc*3);//Кидаем её куда надо...
    }
    delete [] TempStr;
  }
}

void CBitMap::Copy (int X,int Y,CBitMap *BMP)
{
  Paste(-X,-Y,BMP);
}

void CBitMap::Paste(int X,int Y, CBitMap *BMP, CBitMap *Mask, ColorRGB SolidColor)
{
  //Здесь процедура сложнее. Придётся пробежаться по всей картинке, сравнивая попиксельно.
  for(int xx=0;xx<Width();xx++)
    for(int yy=0;yy<Height();yy++)
    {
      //Проверяем, подходит точка к картинке BMP и на месте ли она у нашей картинки
      if((xx>=X)&&(yy>=Y)&&(xx-X<BMP->Width())&&(yy-Y<BMP->Height()))
      {
        //Сравниваем цвет маски (маска по размеру равна this)
        if(Mask->GetPixel(xx,yy)==SolidColor)
        {
          //Тыкнем сюда таким же пикселем. Тупо, но ничего умнее мне в час ночи в голову не лезет.
          SetPixel(xx,yy,BMP->GetPixel(xx-X,yy-Y)); 
        }
      }
    }
}
//---------------------------------------------------------------------------
void CBitMap::Paste(int X,int Y, CBitMap *B1, CBitMap *B2, CBitMap *B3, CTileMask *M)
{
  //B0 = this по умолчанию.
  if((M->Width() == Width())&&(M->Height() == Height())) //Маска по размеру равна нашему рисунку
  {
    ColorRGB Tmp, Rez;
    int TmpR, TmpG, TmpB;
    byte *dwTmp = new byte[4];
    for(int xx=0;xx<Width();xx++)
      for(int yy=0;yy<Height();yy++)
      {
        M->GetPointW(xx,H-yy-1,dwTmp);
        //1-я картинка
        Tmp = GetPixel(xx,yy);
        TmpR = Tmp.Red * dwTmp[0];
        TmpG = Tmp.Green * dwTmp[0];
        TmpB = Tmp.Blue * dwTmp[0];
        //2-я картинка
        if(B1 != NULL)
        {
          Tmp = B1->GetPixel(xx-X,yy-Y);
          TmpR += Tmp.Red * dwTmp[1];
          TmpG += Tmp.Green * dwTmp[1];
          TmpB += Tmp.Blue * dwTmp[1];
        }
        //3-я картинка
        if(B2 != NULL)
        {
          Tmp = B2->GetPixel(xx-X,yy-Y);
          TmpR += Tmp.Red * dwTmp[2];
          TmpG += Tmp.Green * dwTmp[2];
          TmpB += Tmp.Blue * dwTmp[2];
        }
        //4-я картинка
        if(B3 != NULL)
        {
          Tmp = B3->GetPixel(xx-X,yy-Y);
          TmpR += Tmp.Red * dwTmp[3];
          TmpG += Tmp.Green * dwTmp[3];
          TmpB += Tmp.Blue * dwTmp[3];
        }
        Rez.Red = TmpR / 64;
        Rez.Green = TmpG / 64;
        Rez.Blue = TmpB / 64;

        SetPixel(xx,yy,Rez);
      }
    delete [] dwTmp;
  }
}

//------------------------------------------------------------------------------
void CBitMap::Resize(int wSize, int hSize, bool Smooth)
{
  //Процедура изменит размер изображения, растягивая или сжимая его в нужных пропорциях
  if(Inited) //Если картинка нормальная
  {
    if((wSize>0)&&(hSize>0)) //И заданы не фконец идиоЦкие размеры
    {
      CBitMap *Temp = new CBitMap(wSize,hSize,Clr2RGB(0,0,0));
      ColorRGB C1, C2; // Переменные под цвета пикселей, в случае конфлитных координат
      float kX, kY;
      int V1, V2;
      for(int x=0;x<wSize;x++)
      {
        kX = (x)*W*1.0/wSize;
        for(int y=0;y<hSize;y++)
        {
          kY = (y)*H*1.0/hSize;
          if(Smooth)
          {
            C1 = GetPixel(floor(kX), floor(kY));
            C2 = GetPixel(ceil(kX) , ceil(kY) );
            V1 = floor((kX-floor(kX))*100);
            V2 = 100 - V1;
            Temp->SetPixel(x,y,MergePixel(C1,C2,V1,V2));
          }
          else
          {
            Temp->SetPixel(x,y,GetPixel(floor(kX), floor(kY)));
          }
        }
      }
      //Темп сгенерили, теперь присваиваем его нашей картинке
      delete [] Buffer;
      W = Temp->W;
      H = Temp->H;
      Buffer = new byte[PicWeight()];
      memcpy(Buffer,Temp->Buffer,PicWeight());
      delete Temp;
    }
  }
}
//------------------------------------------------------------------------------
CBitMap::ColorRGB CBitMap::MergePixel(ColorRGB P1, ColorRGB P2, int V1, int V2)
{
  ColorRGB Rez;
  Rez.Red   = ((V1/100)*P1.Red   + (V2/100)*P2.Red  );
  Rez.Green = ((V1/100)*P1.Green + (V2/100)*P2.Green);
  Rez.Blue  = ((V1/100)*P1.Blue  + (V2/100)*P2.Blue );
  return Rez;
}
//------------------------------------------------------------------------------
int CBitMap::floor(float X)
{
  return (int)X;
}
//------------------------------------------------------------------------------
int CBitMap::ceil (float X)
{
  int rez=(X-floor(X)<0.001)?floor(X):floor(X+1);//0.001 - константа, эпсилон.
  return rez;
}