//Calcule et renvoie le nombre de couleurs et stocke une palette ainsi qu'un tableau
//représentant l'image 8 bits en utilisant "nbMax" couleurs et une tolérance de
//"différence" unités RVB.
int CalcPalette(unsigned long *tableau, unsigned char *palette, int h, int l, int difference, int nCoulInitiales, int nbBase, int nbMax)		{
	int nbCouleurs=nCoulInitiales, coulTransparente, bestDifference, bestDiffNum;
	int x,y,i;
	unsigned char rouge,vert,bleu;

	memset(palette+nbCouleurs*3,0,(256-nbCouleurs)*3);

	if (tailleVoulueX==0 || tailleVoulueY==0)
		tailleVoulueX=l, tailleVoulueY=h;

	if (b16coul && !optimisePal)
		coulTransparente=nbCouleurs;
	else
		coulTransparente=0;

	for (y=0;y<tailleVoulueY;y++)		{
		for (x=0;x<tailleVoulueX;x++)		{
			if (x>=l || y>=h)		{
				tableau[tailleVoulueX*y+x]=coulTransparente;
			}
			else	{
				LitPixRVB(Bits2,x,y,&rouge,&vert,&bleu);
				if (rouge==rougeMasque && vert==vertMasque && bleu==bleuMasque)		{
					tableau[tailleVoulueX*y+x]=coulTransparente;
					continue;
				}
				rouge=tblCoulR[rouge];
				vert=tblCoulV[vert];
				bleu=tblCoulB[bleu];
/*				for (i=nbBase;i<nbCouleurs;i++)		{
					if (ABS(bleu-palette[3*i])*ABS(bleu-palette[3*i])+ABS(vert-palette[3*i+1])*ABS(vert-palette[3*i+1])+ABS(rouge-palette[3*i+2])*ABS(rouge-palette[3*i+2])<=difference)
//					if (ABS(bleu-palette[3*i])+ABS(vert-palette[3*i+1])+ABS(rouge-palette[3*i+2])<=difference)
						break;
				}*/
				bestDifference=difference, bestDiffNum=-1;
				for (i=nbBase;i<nbCouleurs;i++)		{
					if (ABS(bleu-palette[3*i])*ABS(bleu-palette[3*i])+ABS(vert-palette[3*i+1])*ABS(vert-palette[3*i+1])+ABS(rouge-palette[3*i+2])*ABS(rouge-palette[3*i+2])<=bestDifference)			{
						bestDiffNum=i;
						bestDifference=ABS(bleu-palette[3*i])*ABS(bleu-palette[3*i])+ABS(vert-palette[3*i+1])*ABS(vert-palette[3*i+1])+ABS(rouge-palette[3*i+2])*ABS(rouge-palette[3*i+2]);
					}
				}
				i=bestDiffNum;
				if (i==-1)		{			//La couleur n'existe pas
					i=nbCouleurs;
//				if (i==nbCouleurs)		{			//La couleur n'existe pas
					palette[3*i]=bleu;
					palette[3*i+1]=vert;
					palette[3*i+2]=rouge;
					nbCouleurs++;
					if (nbCouleurs>nbMax)			{
						return -1;
					}
				}
				tableau[tailleVoulueX*y+x]=i+1;
			}
		}
	}
	if (utilMaxCoul)
		nbCouleurs=nbMax;
	return nbCouleurs;
}

void CreeTableauConversion(unsigned long *tableau, unsigned char *palette, int h, int l)				{
	unsigned char rouge,vert,bleu;
	int x,y;
	if (tailleVoulueX==0 || tailleVoulueY==0)
		tailleVoulueX=l, tailleVoulueY=h;
	for (y=0;y<tailleVoulueY;y++)		{
		for (x=0;x<tailleVoulueX;x++)		{
			if (x>=l || y>=h)		{
				if (bTil32Bits==1)
					tableau[tailleVoulueX*y+x]=0xffff;				//Masque
			}
			else	{
				LitPixRVB(Bits2,x,y,&rouge,&vert,&bleu);
				if (rouge==rougeMasque && vert==vertMasque && bleu==bleuMasque)		{
					if (bTil32Bits==1)
						tableau[tailleVoulueX*y+x]=0xffff;				//Masque
					continue;
				}
				if (bTil32Bits==1)			{
					rouge=tblCoulR[rouge];
					vert=tblCoulV[vert];
					bleu=tblCoulB[bleu];
					tableau[tailleVoulueX*y+x]=Rvb15Bits(rouge,vert,bleu);
				}
			}
		}
	}
}


//Calcule et renvoie le nombre de couleurs et stocke une palette ainsi qu'un tableau
//représentant l'image 8 bits en utilisant "nbMax" couleurs et une tolérance de
//"différence" unités RVB.
int CalcPaletteBmp8(unsigned long *tableau, unsigned char *palette, int h, int l, int difference, int nCoulInitiales, int nbBase, int nbMax)		{
	int nbCouleurs=nCoulInitiales;
	int x,y,i, bestDifference, bestDiffNum;
	unsigned char rouge,vert,bleu;

	tailleVoulueX=l, tailleVoulueY=h;
	memset(palette+nbCouleurs*3,0,(256-nbCouleurs)*3);

	for (y=0;y<tailleVoulueY;y++)		{
		for (x=0;x<tailleVoulueX;x++)		{
			if (x>=l || y>=h)		{
				tableau[tailleVoulueX*y+x]=0;
			}
			else	{
				LitPixRVB(Bits2,x,y,&rouge,&vert,&bleu);
				//Support couleur transparente
				if (rouge==rougeMasque && vert==vertMasque && bleu==bleuMasque)		{
					tableau[tailleVoulueX*y+x]=0;
					continue;
				}
				//Fin support
				rouge=tblCoulR[rouge];
				vert=tblCoulV[vert];
				bleu=tblCoulB[bleu];

/*				for (i=nbBase;i<nbCouleurs;i++)		{
					if (ABS(bleu-palette[3*i])*ABS(bleu-palette[3*i])+ABS(vert-palette[3*i+1])*ABS(vert-palette[3*i+1])+ABS(rouge-palette[3*i+2])*ABS(rouge-palette[3*i+2])<=difference)
//					if (ABS(bleu-palette[3*i])+ABS(vert-palette[3*i+1])+ABS(rouge-palette[3*i+2])<=difference)
						break;
				}
				if (i==nbCouleurs)		{			//La couleur n'existe pas
					palette[3*i]=bleu;
					palette[3*i+1]=vert;
					palette[3*i+2]=rouge;
					nbCouleurs++;
					if (nbCouleurs>nbMax)
						return -1;
				}
				//+1 = support couleur transparente
				tableau[tailleVoulueX*y+x]=i+1;*/
				//Nouvelle méthode
				bestDifference=difference, bestDiffNum=-1;
				for (i=nbBase;i<nbCouleurs;i++)		{
					if (ABS(bleu-palette[3*i])*ABS(bleu-palette[3*i])+ABS(vert-palette[3*i+1])*ABS(vert-palette[3*i+1])+ABS(rouge-palette[3*i+2])*ABS(rouge-palette[3*i+2])<=bestDifference)			{
						bestDiffNum=i;
						bestDifference=ABS(bleu-palette[3*i])*ABS(bleu-palette[3*i])+ABS(vert-palette[3*i+1])*ABS(vert-palette[3*i+1])+ABS(rouge-palette[3*i+2])*ABS(rouge-palette[3*i+2]);
					}
				}
				i=bestDiffNum;
				if (i==-1)		{			//La couleur n'existe pas
					i=nbCouleurs;
//				if (i==nbCouleurs)		{			//La couleur n'existe pas
					palette[3*i]=bleu;
					palette[3*i+1]=vert;
					palette[3*i+2]=rouge;
					nbCouleurs++;
					if (nbCouleurs>nbMax)			{
						return -1;
					}
				}
				tableau[tailleVoulueX*y+x]=i+1;
			}
		}
	}
	if (utilMaxCoul)
		nbCouleurs=nbMax;
	return nbCouleurs;
}




HDC gblHDC;
HBITMAP gblHbm;
unsigned char *BitsConv;
PALETTEENTRY lapalette[256];

//Crée une DIB de taille "cx" et "cy" pour pouvoir y dessiner en l'utilisant comme un
//bloc de mémoire de "ibitcount" bits par pixel. La sélectionne dans "hdc" et la stocke
//dans "hbm". Le pointeur sur les bits de cette bitmap sera écrit dans "bits".
int CreeDIB2(HDC hdc, int cx, int cy, int ibitcount, HBITMAP *hbm, void **bits, PALETTEENTRY* pPalEntries, int nCouleurs) 
{
   // Create a BITMAPINFOHEADER structure to describe the DIB.
   int iSize = sizeof(BITMAPINFOHEADER)+sizeof (PALETTEENTRY)*nCouleurs;
   int i;
   BITMAPINFO *bi;

   bi=(BITMAPINFO*)malloc(iSize);
   ASSERT((ibitcount == 8) || (ibitcount == 16) || (ibitcount == 24)) ;
   ASSERT(cx > 0);
   ASSERT(cy > 0);
   memset(&BIH, 0, sizeof(BITMAPINFOHEADER));

   // Fill in the header info. 
   BIH.biSize = sizeof(BITMAPINFOHEADER);
   BIH.biWidth = cx;
   BIH.biHeight = cy+1;
   BIH.biPlanes = 1;
   BIH.biBitCount = ibitcount;
   BIH.biCompression = BI_RGB;
   BIH.biClrUsed=nCouleurs;

   bi->bmiHeader=BIH;
//   memcpy(&bi->bmiColors,pPalEntries,sizeof (PALETTEENTRY)*nCouleurs);
   memset(&bi->bmiColors,0,sizeof (PALETTEENTRY)*nCouleurs);
   for (i=0;i<nCouleurs;i++)		{
	   bi->bmiColors[i].rgbRed=lapalette[i].peRed;
	   bi->bmiColors[i].rgbGreen=lapalette[i].peGreen;
	   bi->bmiColors[i].rgbBlue=lapalette[i].peBlue;
   }

   // Create a new device context.

   // Create the DIB section.
   *hbm = CreateDIBSection(hdc,
               (BITMAPINFO*) bi,
                             DIB_RGB_COLORS,
                             (void**)bits,
                             NULL,
                             0);
	
    ASSERT(*hbm);
    ASSERT(*bits);

    // Select the new bitmap into the buffer DC.
    if (*hbm && *bits)
    {
        SelectObject(hdc,*hbm);
		return 1;
    }
	else	{
		return 0;
	}
}


int ReductionHalftone(unsigned long *tableau, unsigned char *palette, int h, int l)		{
    HPALETTE hPalette;
	DIBSECTION ds;
	int i,cx,cy,x,y, nPad,nPad2, r,v,b, bas;
	unsigned char *ptr, *ptr2;
	HDC hdcEcran;

	hdcEcran=GetDC(NULL);
    hPalette = CreateHalftonePalette (hdcEcran);
	GetPaletteEntries(hPalette,0,256,lapalette);

	GetObject (hbmConv, sizeof (ds), &ds);
    nPad2 = ds.dsBm.bmWidthBytes - (((ds.dsBmih.biWidth *
        ds.dsBmih.biBitCount) + 7) / 8);

	lapalette[245].peBlue=255;
	lapalette[245].peGreen=255;
	lapalette[245].peRed=255;

	lapalette[255].peBlue=1;
	lapalette[255].peGreen=0;
	lapalette[255].peRed=0;

	gblHDC=CreateCompatibleDC(hdcEcran);
	cx=ds.dsBmih.biWidth;
	cy=ds.dsBmih.biHeight;
	CreeDIB2(gblHDC,cx,cy,8,&gblHbm,(void**)&BitsConv,lapalette,256);
	SelectObject(gblHDC,gblHbm);

	SetStretchBltMode(gblHDC,HALFTONE);
	StretchBlt(gblHDC,0,0,cx,cy,hdcConv,0,0,cx,cy,SRCCOPY);

	for (i=0;i<256;i++)		{
		palette[3*i]=tblCoulB[lapalette[i].peBlue];
		palette[3*i+1]=tblCoulV[lapalette[i].peGreen];
		palette[3*i+2]=tblCoulR[lapalette[i].peRed];
	}

	if (tailleVoulueX==0 || tailleVoulueY==0)
		tailleVoulueX=l, tailleVoulueY=h;

	nPad=(4-(cx&3))&3;

	ptr=BitsConv+cx+nPad;
	ptr2=(unsigned char *)ds.dsBm.bmBits;
	bas=tailleVoulueY-1-(tailleVoulueY-h);

	for (y=0;y<tailleVoulueY;y++)		{
		for (x=0;x<tailleVoulueX;x++)		{
			if (y>=h)
				tableau[y*tailleVoulueX+x]=0;
			else if (x>=l)
				tableau[(bas-y)*tailleVoulueX+x]=0;
			else	{
				b=*ptr2;
				v=*(ptr2+1);
				r=*(ptr2+2);
				ptr2+=3;
				if (r==rougeMasque && v==vertMasque && b==bleuMasque)
					tableau[(bas-y)*tailleVoulueX+x]=0;
				else
					tableau[(bas-y)*tailleVoulueX+x]=(*ptr)+1;
				ptr++;
			}
		}
		ptr+=nPad;
		ptr2+=nPad2;
	}

	DeleteObject(hPalette);
	DeleteObject(gblHbm);
	DeleteDC(gblHDC);
	DeleteDC(hdcConv);
	DeleteObject(hbmConv);
	ReleaseDC(NULL,hdcEcran);

	return 255;
}








/***********************************************
			OCTREE
************************************************/

int nbreCouleursPalette;

typedef struct _NODE {
    BOOL bIsLeaf;               // TRUE if node has no children
    UINT nPixelCount;           // Number of pixels represented by this leaf
    UINT nRedSum;               // Sum of red components
    UINT nGreenSum;             // Sum of green components
    UINT nBlueSum;              // Sum of blue components
    struct _NODE* pChild[8];    // Pointers to child nodes
    struct _NODE* pNext;        // Pointer to next reducible node
} NODE;

HPALETTE CreateOctreePalette (unsigned long *, HANDLE, UINT, UINT);
void AddColor (NODE**, BYTE, BYTE, BYTE, UINT, UINT, UINT*, NODE**);
NODE* CreateNode (UINT, UINT, UINT*, NODE**);
void ReduceTree (UINT, UINT*, NODE**);
void DeleteTree (NODE**);
void GetPaletteColors (NODE*, PALETTEENTRY*, UINT*);

HPALETTE CreateOctreePalette (unsigned long *tableau, HANDLE hImage, UINT nMaxColors, UINT nColorBits)
{
    DIBSECTION ds;
    int i, j, nPad, bas;
    BYTE* pbBits;
    BYTE r, g, b;
    DWORD dwSize;
    LOGPALETTE* plp;
    HPALETTE hPalette;
    NODE* pTree;
    UINT nLeafCount, nIndex;
    NODE* pReducibleNodes[9];
	HDC hdcEcran;

	hdcEcran=GetDC(NULL);
    // Initialize octree variables
    pTree = NULL;
    nLeafCount = 0;
    if (nColorBits > 8) // Just in case
        return NULL;
    for (i=0; i<=(int) nColorBits; i++)
        pReducibleNodes[i] = NULL;

    // Scan the DIB and build the octree
    GetObject (hImage, sizeof (ds), &ds);
    nPad = ds.dsBm.bmWidthBytes - (((ds.dsBmih.biWidth *
        ds.dsBmih.biBitCount) + 7) / 8);

	bas=tailleVoulueY-1-(tailleVoulueY-ds.dsBmih.biHeight);

    switch (ds.dsBmih.biBitCount) {

    case 24: // Another for 24-bit DIBs
        pbBits = (BYTE*) ds.dsBm.bmBits;
        for (i=0; i<ds.dsBmih.biHeight; i++) {
            for (j=0; j<ds.dsBmih.biWidth; j++) {
				if (*(pbBits+2)==rougeMasque && *(pbBits+1)==vertMasque && *(pbBits)==bleuMasque)		{
					tableau[(bas-i)*tailleVoulueX+j]=124;
					pbBits+=3;
				}
				else		{
					tableau[(bas-i)*tailleVoulueX+j]=0;
					*pbBits=tblCoulB[*pbBits]*MULT;
					b = *pbBits++;
					*pbBits=tblCoulV[*pbBits]*MULT;
					g = *pbBits++;
					*pbBits=tblCoulR[*pbBits]*MULT;
					r = *pbBits++;
					AddColor (&pTree, r, g, b, nColorBits, 0, &nLeafCount,
							  pReducibleNodes);
					while (nLeafCount > nMaxColors)
						ReduceTree (nColorBits, &nLeafCount, pReducibleNodes);
				}
            }
            pbBits += nPad;
        }
        break;

    default: // DIB must be 16, 24, or 32-bit!
        return NULL;
    }

    if (nLeafCount > nMaxColors) { // Sanity check
        DeleteTree (&pTree);
        return NULL;
    }

    // Create a logical palette from the colors in the octree
    dwSize = sizeof (LOGPALETTE) + ((nLeafCount - 1) * sizeof (PALETTEENTRY));
    if ((plp = (LOGPALETTE*) HeapAlloc (GetProcessHeap (), 0,
        dwSize)) == NULL) {
        DeleteTree (&pTree);
        return NULL;
    }

    plp->palVersion = 0x300;
    plp->palNumEntries = (WORD) nLeafCount;
    nIndex = 0;

    GetPaletteColors (pTree, plp->palPalEntry, &nIndex);

	hPalette = CreatePalette (plp);


	memcpy(lapalette,plp->palPalEntry,nLeafCount*sizeof(PALETTEENTRY));
	nbreCouleursPalette=nLeafCount;

	gblHDC=CreateCompatibleDC(hdcEcran);
	CreeDIB2(gblHDC,ds.dsBmih.biWidth,ds.dsBmih.biHeight,8,&gblHbm,(void**)&BitsConv,plp->palPalEntry,nLeafCount);
	SelectObject(gblHDC,gblHbm);


    HeapFree (GetProcessHeap (), 0, plp);
    DeleteTree (&pTree);
	ReleaseDC(NULL,hdcEcran);
    return hPalette;
}

void AddColor (NODE** ppNode, BYTE r, BYTE g, BYTE b, UINT nColorBits,
    UINT nLevel, UINT* pLeafCount, NODE** pReducibleNodes)
{
    int nIndex, shift;
    static BYTE mask[8] = { 0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01 };

    // If the node doesn't exist, create it
    if (*ppNode == NULL)
        *ppNode = CreateNode (nLevel, nColorBits, pLeafCount,
                              pReducibleNodes);

    // Update color information if it's a leaf node
    if ((*ppNode)->bIsLeaf) {
        (*ppNode)->nPixelCount++;
        (*ppNode)->nRedSum += r;
        (*ppNode)->nGreenSum += g;
        (*ppNode)->nBlueSum += b;
    }

    // Recurse a level deeper if the node is not a leaf
    else {
        shift = 7 - nLevel;
        nIndex = (((r & mask[nLevel]) >> shift) << 2) |
            (((g & mask[nLevel]) >> shift) << 1) |
            ((b & mask[nLevel]) >> shift);
        AddColor (&((*ppNode)->pChild[nIndex]), r, g, b, nColorBits,
                  nLevel + 1, pLeafCount, pReducibleNodes);
    }
}

NODE* CreateNode (UINT nLevel, UINT nColorBits, UINT* pLeafCount,
                  NODE** pReducibleNodes)
{
    NODE* pNode;

    if ((pNode = (NODE*) HeapAlloc (GetProcessHeap (), HEAP_ZERO_MEMORY,
        sizeof (NODE))) == NULL)
        return NULL;

    pNode->bIsLeaf = (nLevel == nColorBits) ? TRUE : FALSE;
    if (pNode->bIsLeaf)
        (*pLeafCount)++;
    else { // Add the node to the reducible list for this level
        pNode->pNext = pReducibleNodes[nLevel];
        pReducibleNodes[nLevel] = pNode;
    }
    return pNode;
}

void ReduceTree (UINT nColorBits, UINT* pLeafCount, NODE** pReducibleNodes)
{
    int i;
    NODE* pNode;
    UINT nRedSum, nGreenSum, nBlueSum, nChildren;

    // Find the deepest level containing at least one reducible node
    for (i=nColorBits - 1; (i>0) && (pReducibleNodes[i] == NULL); i--);

    // Reduce the node most recently added to the list at level i
    pNode = pReducibleNodes[i];
    pReducibleNodes[i] = pNode->pNext;

    nRedSum = nGreenSum = nBlueSum = nChildren = 0;
    for (i=0; i<8; i++) {
        if (pNode->pChild[i] != NULL) {
            nRedSum += pNode->pChild[i]->nRedSum;
            nGreenSum += pNode->pChild[i]->nGreenSum;
            nBlueSum += pNode->pChild[i]->nBlueSum;
            pNode->nPixelCount += pNode->pChild[i]->nPixelCount;
            HeapFree (GetProcessHeap (), 0, pNode->pChild[i]);
            pNode->pChild[i] = NULL;
            nChildren++;
        }
    }

    pNode->bIsLeaf = TRUE;
    pNode->nRedSum = nRedSum;
    pNode->nGreenSum = nGreenSum;
    pNode->nBlueSum = nBlueSum;
    *pLeafCount -= (nChildren - 1);
}

void DeleteTree (NODE** ppNode)
{
    int i;

    for (i=0; i<8; i++) {
        if ((*ppNode)->pChild[i] != NULL)
            DeleteTree (&((*ppNode)->pChild[i]));
    }
    HeapFree (GetProcessHeap (), 0, *ppNode);
    *ppNode = NULL;
}

void GetPaletteColors (NODE* pTree, PALETTEENTRY* pPalEntries, UINT* pIndex)
{
    int i;

    if (pTree->bIsLeaf) {
        pPalEntries[*pIndex].peRed =
            (BYTE) ((pTree->nRedSum) / (pTree->nPixelCount));
        pPalEntries[*pIndex].peGreen =
            (BYTE) ((pTree->nGreenSum) / (pTree->nPixelCount));
        pPalEntries[*pIndex].peBlue =
            (BYTE) ((pTree->nBlueSum) / (pTree->nPixelCount));
        (*pIndex)++;
    }
    else {
        for (i=0; i<8; i++) {
            if (pTree->pChild[i] != NULL)
                GetPaletteColors (pTree->pChild[i], pPalEntries, pIndex);
        }
    }
}





int ReductionOctree(unsigned long *tableau, unsigned char *palette, int h, int l, int nCoulInitiales, int nCoul)		{
	HPALETTE hPalette;
	DIBSECTION ds;
	int i,j,cx,cy,x,y, nPad, bas;
	unsigned char *ptr;

	if (nCoul-nCoulInitiales<=1)		{
		CacheTravail();
		MessageBox(gblHDlg,"Le nombre de couleurs disponible est trop bas pour cette conversion.","Erreur fatale",MB_ICONERROR);
		return 0;
	}
	nbreCouleursPalette=0;
	hPalette=CreateOctreePalette(tableau,hbmConv,nCoul-nCoulInitiales,8);

	if (nbreCouleursPalette<=1)		{
		CacheTravail();
		MessageBox(gblHDlg,"Impossible de convertir la bitmap car le nombre de couleurs requis ne peut être atteint","Oups...",MB_ICONERROR);
		return 0;
	}

	GetObject (hbmConv, sizeof (ds), &ds);

	cx=ds.dsBmih.biWidth;
	cy=ds.dsBmih.biHeight;
//	CreeDIB2(gblHDC,cx,cy,8,&gblHbm,(void**)&BitsConv,lapalette,256);
	SelectObject(gblHDC,gblHbm);

	SetStretchBltMode(gblHDC,COLORONCOLOR);
	StretchBlt(gblHDC,0,0,cx,cy,hdcConv,0,0,cx,cy,SRCCOPY);

	for (i=0;i<nbreCouleursPalette;i++)		{
		j=i+nCoulInitiales;
		palette[3*j]=lapalette[i].peBlue/MULT;
		palette[3*j+1]=lapalette[i].peGreen/MULT;
		palette[3*j+2]=lapalette[i].peRed/MULT;
	}

	if (tailleVoulueX==0 || tailleVoulueY==0)
		tailleVoulueX=l, tailleVoulueY=h;

//    nPad = ds.dsBm.bmWidthBytes - (((ds.dsBmih.biWidth *
//        ds.dsBmih.biBitCount) + 7) / 8);
	nPad=(4-(cx&3))&3;

	ptr=BitsConv+cx+nPad;
	bas=tailleVoulueY-1-(tailleVoulueY-h);

	for (y=0;y<tailleVoulueY;y++)		{
		for (x=0;x<tailleVoulueX;x++)		{
			if (y>=h)
				tableau[y*tailleVoulueX+x]=0;
			else if (x>=l)
				tableau[(bas-y)*tailleVoulueX+x]=0;
			else	{
				if (tableau[(bas-y)*tailleVoulueX+x]==124)
					tableau[(bas-y)*tailleVoulueX+x]=0;
				else
					tableau[(bas-y)*tailleVoulueX+x]=(*ptr)+1+nCoulInitiales;
				ptr++;
			}
		}
		ptr+=nPad;
	}

	DeleteObject(gblHbm);
	DeleteDC(gblHDC);
	DeleteDC(hdcConv);
	DeleteObject(hbmConv);
	DeleteObject(hPalette);
	return nbreCouleursPalette+nCoulInitiales;
}






