/************************************************************* * Unit: raster release 0.40 * * Purpose: General manipulation n dimensional matrices * * n = 1, 2 and 3. * * Modul: raster.cc * * Licency: GPL or LGPL * * Copyright: (c) 1998-2026 Jaroslav Fojtik * *************************************************************/ #include #include #include #ifdef HI_ENDIAN #include #endif #include "common.h" #include "raster.h" #include "ras_prot.h" #if defined(uint64_t_defined) #ifndef _UI64_MAX #ifdef __BORLANDC__ #define _UI64_MAX 18446744073709551615ui64 #else #define _UI64_MAX 0xFFFFFFFFFFFFFFFFll #endif #endif #endif /// Get nearly available amount of planes thatis supported by rasters. int NearAvailPlanes(int n) { if(n<1) { if(n==0) return 0; if(n>=-32) return -32; // float return -64; // double } if(n<=1) return(1); // bit if(n<=2) return(2); if(n<=4) return(4); // nibble if(n<=8) return(8); // byte if(n<=16) return(16); // word if(n<=24) return(24); if(n<=32) return(32); // dword if(n<=64) return(64); // qword return(n); } void Raster1DAbstract::Erase1DStub(void) { if(Shadow) { Data1D = NULL; Size1D = 0; return; } if(Data1D!=NULL) {free(Data1D);Data1D=NULL;} Size1D = 0; } void Raster1DAbstract::Allocate1D(unsigned NewSize1D) { if(Data1D!=NULL) { if(Size1D==NewSize1D) return; // No reallocation needed. free(Data1D); Data1D=NULL; } if(NewSize1D==0) return; const unsigned long SzBit = (unsigned long)labs(GetPlanes()) * NewSize1D; Data1D = malloc((SzBit+7)/8); if(Data1D!=NULL) { if((SzBit & 7) != 0) // Incomplete padding byte should be cleared to prevent walgrind errors to access uninitialised memory. *((uint8_t*)Data1D + SzBit/8) = 0; // This is not neccessary for normal functionality. } // Storing one junk byte will not hurt. else RaiseError(RasterId|No_Memory,this); Size1D = NewSize1D; } void Raster1DAbstract::Cleanup(void) { if(Data1D==NULL) return; memset(Data1D, 0, (Size1D+7)*GetPlanes()/8); } /** Push data to a given container. */ void Raster1DAbstract::Get(Raster1DAbstract &R1) const { int i, maxi; int shift; const signed char BasePlanes = GetPlanes(); const signed char R1_Planes = R1.GetPlanes(); maxi = (Size1D>R1.Size1D) ? Size1D : R1.Size1D; if(R1_Planes == BasePlanes) { if(Data1D!=NULL && R1.Data1D!=NULL) memcpy(R1.Data1D, Data1D, ((long)maxi*labs(GetPlanes())+7)/8); return; } if(R1_Planes<0 || BasePlanes<0) // Floating point conversion { if(R1_Planes<0 && BasePlanes<0) // Both source and target are FP. { for(i=0; i32) i=32; if(shift>32) shift=32; #endif shift = i - shift; #if defined(uint64_t_defined) if(shift==0) // Also used for cropped 64 bit values. { for(i=0; i0) { for(i=0; i>shift); } } /** Copy data from a given container. */ void Raster1DAbstract::Set(const Raster1DAbstract &R1) { unsigned i, maxi; signed char shift; signed char BasePlanes, SetPlanes; if(Data1D==NULL || R1.Data1D==NULL) return; maxi = Size1D>R1.Size1D ? Size1D : R1.Size1D; BasePlanes = GetPlanes(); SetPlanes = R1.GetPlanes(); if(BasePlanes == SetPlanes) // No bitplane change - copy data only { i = Size1D; if(R1.Size1D=0) { int k = 3* ((1< 32) SetPlanes=32; if(BasePlanes > 32) BasePlanes=32; shift = BasePlanes - SetPlanes; if(shift>0) { unsigned k = 0; while(shift >= 0) // Needs to replicate lower bits. { k |= 1 << shift; shift -= R1.GetPlanes(); } for(i=0; i>shift); return; } } #ifdef _REENTRANT void Raster1DAbstract::PTR_Get(const void *RAW_Data1D, Raster1DAbstract &R1) const { int i,maxi; int shift; maxi = Size1D>R1.Size1D?Size1D:R1.Size1D; if(R1.GetPlanes()==GetPlanes()) { if(Data1D!=NULL && R1.Data1D!=NULL) memcpy(R1.Data1D, RAW_Data1D, ((long)maxi*labs(GetPlanes())+7)/8); return; } if(R1.GetPlanes()<0 || GetPlanes()<0) // Floating point conversion { if(GetPlanes()<0) // Both source and target are FP. { for(i=0; i0) { for(i=0;i>shift); } } void Raster1DAbstract::PTR_Set(void *RAW_Data1D, const Raster1DAbstract &R1) { unsigned i,maxi; signed char shift; if(Data1D==NULL || R1.Data1D==NULL) return; maxi = Size1D>R1.Size1D?Size1D:R1.Size1D; if(GetPlanes()==R1.GetPlanes()) // No bitplane change - copy data only { i = Size1D; // Minimal equal range if(R1.Size1D0) { for(i=0;i>shift); return; } } #endif void Raster1DAbstract::Get24BitRGB(void *Buffer24Bit) const { uint8_t *N_Buffer24Bit = (uint8_t *)Buffer24Bit; if(Buffer24Bit==NULL) return; { Raster1D_8Bit Helper; Helper.Data1D = Buffer24Bit; Helper.Size1D = Size1D; Helper.Set(*this); // convert to 8 bits. Helper.Data1D = NULL; } // In place conversion, must iterate from the end. for(int i=Size1D-1; i>=0; i--) { N_Buffer24Bit[3*i] = N_Buffer24Bit[3*i+1] = N_Buffer24Bit[3*i+2] = N_Buffer24Bit[i]; } } /* Specialised Raster 1D modules */ /// param[out] Buffer1Bit Buffer to get 1bpp image. /// param[in] plane Plane No to be extracted. void Raster1DAbstract::Peel1Bit(void *Buffer1Bit, uint8_t plane) const { uint8_t Buff = 0; uint8_t Mask = 0x80; if(Buffer1Bit==NULL) return; if(plane>=labs(GetPlanes())) { memset(Buffer1Bit,0,(Size1D+7)/8); return; } for(unsigned i=0; i>plane)&1) Buff|=Mask; Mask >>= 1; if(Mask==0) { *((uint8_t*)Buffer1Bit) = Buff; Buffer1Bit = ((uint8_t*)Buffer1Bit)+1; Mask = 0x80; Buff = 0; } } if(Mask!=0x80) *(uint8_t*)Buffer1Bit = Buff; } void Raster1DAbstract::Join1Bit(const void *Buffer1Bit, uint8_t plane) { unsigned i; unsigned MaskPos, iMaskPos; uint8_t Mask = 0x80; uint8_t Buff; if(Buffer1Bit==NULL || Size1D==0 || plane>=labs(GetPlanes())) return; // Nothing to do, bit layer is padding. iMaskPos = (1l<>= 1; if(Mask==0) { Buffer1Bit = ((const uint8_t*)Buffer1Bit)+1; Mask = 0x80; Buff = *(const uint8_t*)Buffer1Bit; } } } /** Joins 8 bit channel into raster data on given bit wise position. * Use 0,8,16 for RGB 8bit channels. */ void Raster1DAbstract::Join8Bit(const void *Buffer8Bit, uint8_t plane8) { Raster1D_8Bit R8; int i,maxi; long mask; if(plane8>=labs(GetPlanes()) || Buffer8Bit==NULL || Data1D==NULL) return; R8.Data1D=(void*)Buffer8Bit;R8.Size1D=Size1D; R8.Shadow=true; maxi=Size1D>R8.Size1D?Size1D:R8.Size1D; mask=~(0xFFl<= labs(GetPlanes())) { memset(Buffer8Bit,0,Size1D); return; } for(unsigned i=0; i>plane8) & 0xFF; Buffer8Bit = 1 + (uint8_t*)Buffer8Bit; #else *((uint8_t*)Buffer8Bit)++ = (GetValue1D(i)>>plane8) & 0xFF; #endif } } /* -------------- 1 bit planes --------------- */ void Raster1D_1Bit::SetValue1D(unsigned x, uint32_t NewValue) { uint8_t *b; if(x>=Size1D || Data1D==NULL) return; b = (uint8_t *)Data1D + (x >> 3); if(NewValue==0) *b = *b & ~(0x80 >>(x & 0x07)); else *b = *b | (0x80 >>(x & 0x07)); } uint32_t Raster1D_1Bit::GetValue1D(unsigned x) const { const uint8_t *b; if(x>=Size1D || Data1D==NULL) return(0); b = (const uint8_t *)Data1D + (x >> 3); if((*b & (0x80 >>(x & 0x07))) != 0) return(1); return(0); } #ifdef _REENTRANT void Raster1D_1Bit::PTR_SetValue1D(void *RAW_Data1D, unsigned x, uint32_t NewValue) const { uint8_t *b; if(x>=Size1D || RAW_Data1D==NULL) return; b = (uint8_t *)RAW_Data1D + (x >> 3); if(NewValue==0) *b = *b & ~(0x80 >>(x & 0x07)); else *b = *b | (0x80 >>(x & 0x07)); } uint32_t Raster1D_1Bit::PTR_GetValue1D(const void *RAW_Data1D, unsigned x) const { const uint8_t *b; if(x>=Size1D || RAW_Data1D==NULL) return(0); b = (const uint8_t *)RAW_Data1D + (x >> 3); if((*b & (0x80 >>(x & 0x07))) != 0) return(1); return(0); } #endif #ifdef OPTIMISE_SPEED void Raster1D_1Bit::Set(const Raster1DAbstract &R1) { int i; i = R1.GetPlanes(); switch(i) { case -32: case -64: // Do not process floats here case -1: case 1: Raster1DAbstract::Set(R1); return; case 2: Conv2_1((uint8_t *)Data1D,(const uint8_t *)R1.Data1D,Size1D); return; case -4: case 4: Conv4_1((uint8_t *)Data1D,(const uint8_t *)R1.Data1D,Size1D); return; case -8: case 8: Conv8_1((uint8_t *)Data1D,(const uint8_t *)R1.Data1D,Size1D); return; case -16: case 16:Conv16_1((uint8_t *)Data1D,(const uint16_t *)R1.Data1D,Size1D); return; case 24: Conv24_1((uint8_t *)Data1D,(const uint8_t *)R1.Data1D,Size1D); return; case 32:Conv32_1((uint8_t *)Data1D,(const uint32_t *)R1.Data1D,Size1D); return; #if defined(Conv64_1) case 64:Conv64_1((uint8_t *)Data1D,(const uint64_t *)R1.Data1D,Size1D); return; #endif } if(i<0) // -32 and -64 are floats. { // Converting from float to int is not fully implemented return; } else { uint8_t *N_Buffer8Bit = (uint8_t *)Data1D - 1; const uint32_t Half = 1 << (i-1); uint8_t Mask = 0; for(unsigned x=0; x>= 1; if(Mask == 0) { ++N_Buffer8Bit; *N_Buffer8Bit = 0; Mask = 0x80; } if(R1.GetValue1D(x)>=Half) *N_Buffer8Bit|=Mask; } } } void Raster1D_1Bit::Get(Raster1DAbstract &R1) const { const uint8_t *N_Buffer8Bit = (uint8_t *)Data1D; uint8_t Mask; uint32_t Max; int i = R1.GetPlanes(); switch(i) { case 1: Raster1DAbstract::Get(R1); return; case 2: Conv1_2((uint8_t *)R1.Data1D,(const uint8_t *)Data1D,Size1D); return; case 4: Conv1_4((uint8_t *)R1.Data1D,(const uint8_t *)Data1D,Size1D); return; case 8: Conv1_8((uint8_t *)R1.Data1D,(const uint8_t *)Data1D,Size1D); return; case 16:Conv1_16((uint16_t *)R1.Data1D,(const uint8_t *)Data1D,Size1D); return; case 24: Conv1_24((uint8_t *)R1.Data1D,(const uint8_t *)Data1D,Size1D); return; case 32:Conv1_32((uint32_t *)R1.Data1D,(const uint8_t *)Data1D,Size1D); return; #if defined(uint64_t_defined) case 64:Conv1_64((uint64_t*)R1.Data1D,(const uint8_t *)Data1D,Size1D); return; #endif } Mask = 0x80; if(i<=0) Max = 1; else {Max = 1 << (i-1); Max = Max + (Max-1);} for(i=0; i>= 1; if(Mask==0) { Mask = 0x80; N_Buffer8Bit++; } } } void Raster1D_1Bit::Peel1Bit(void *Buffer1Bit, uint8_t plane) const { if(Data1D==NULL) return; if(plane==0) { memcpy(Buffer1Bit,Data1D,(Size1D+7)/8); } else { memset(Buffer1Bit,0,(Size1D+7)/8); } } void Raster1D_1Bit::Join1Bit(const void *Buffer1Bit, uint8_t plane) { if(plane==0) memcpy(Data1D,Buffer1Bit,(Size1D+7)/8); } #endif // OPTIMISE_SPEED /* --------------- 2 bit planes ------------- */ void Raster1D_2Bit::SetValue1D(unsigned x, uint32_t NewValue) { uint8_t *b=(uint8_t *)Data1D; uint8_t v; v=NewValue; if(NewValue>3) v=3; b+= x >> 2; switch(x & 3) { case 0:v=v << 6; *b=*b & 0x3F; break; case 1:v=v << 4; *b=*b & 0xCF; break; case 2:v=v << 2; *b=*b & 0xF3; break; case 3:*b=*b & 0xFC; } *b=*b | v; } uint32_t Raster1D_2Bit::GetValue1D(unsigned x) const { const uint8_t *b; if(Data1D==NULL || x>=Size1D) return 0; b = (const uint8_t *)Data1D + (x >> 2); switch(x & 3) { case 0:return( (*b >> 6)&3 ); case 1:return( (*b >> 4)&3 ); case 2:return( (*b >> 2)&3 ); case 3:return( *b & 3 ); } return 0; } #ifdef _REENTRANT void Raster1D_2Bit::PTR_SetValue1D(void *RAW_Data1D, unsigned x, uint32_t NewValue) const { uint8_t *b = (uint8_t *)RAW_Data1D; uint8_t v; v = NewValue; if(NewValue>3) v=3; b+= x >> 2; switch(x & 3) { case 0:v=v << 6; *b=*b & 0x3F; break; case 1:v=v << 4; *b=*b & 0xCF; break; case 2:v=v << 2; *b=*b & 0xF3; break; case 3:*b=*b & 0xFC; } *b = *b | v; } uint32_t Raster1D_2Bit::PTR_GetValue1D(const void *RAW_Data1D, unsigned x) const { const uint8_t *b; if(RAW_Data1D==NULL || x>=Size1D) return 0; b = (const uint8_t *)RAW_Data1D + (x >> 2); switch(x & 3) { case 0:return( (*b >> 6)&3 ); case 1:return( (*b >> 4)&3 ); case 2:return( (*b >> 2)&3 ); case 3:return( *b & 3 ); } return 0; } #endif #ifdef OPTIMISE_SPEED void Raster1D_2Bit::Get(Raster1DAbstract &R1) const { switch(R1.GetPlanes()) { case 1: Conv2_1((uint8_t*)R1.Data1D,(const uint8_t*)Data1D,Size1D); return; case 8: Conv2_8((uint8_t*)R1.Data1D,(const uint8_t*)Data1D,Size1D); return; case 16:Conv2_16((uint16_t*)R1.Data1D,(const uint8_t*)Data1D,Size1D); return; case 24:Conv2_24((uint8_t*)R1.Data1D,(const uint8_t*)Data1D,Size1D); return; case 32:Conv2_32((uint32_t*)R1.Data1D,(const uint8_t*)Data1D,Size1D); return; } Raster1DAbstract::Get(R1); } void Raster1D_2Bit::Set(const Raster1DAbstract &R1) { switch(R1.GetPlanes()) { case 1: Conv1_2((uint8_t*)Data1D,(const uint8_t*)R1.Data1D,Size1D); return; } Raster1DAbstract::Set(R1); } #endif /* ------------- 4 bit planes ------------- */ void Raster1D_4Bit::SetValue1D(unsigned x, uint32_t NewValue) { uint8_t *b=(uint8_t *)Data1D; if(x>=Size1D) return; b+= x >> 1; if (x & 1) *b=(*b & 0xF0) | (NewValue & 0x0F); else *b=(*b & 0x0F) | ((NewValue << 4) & 0xF0); } uint32_t Raster1D_4Bit::GetValue1D(unsigned x) const { const uint8_t *b=(uint8_t *)Data1D; if(x>=Size1D) return 0; b+= x >> 1; if(x & 1) return(*b & 0x0F); else return(*b >> 4); } #ifdef _REENTRANT void Raster1D_4Bit::PTR_SetValue1D(void *RAW_Data1D, unsigned x, uint32_t NewValue) const { uint8_t *b = (uint8_t *)RAW_Data1D; if(x>=Size1D || RAW_Data1D==NULL) return; b+= x >> 1; if (x & 1) *b=(*b & 0xF0) | (NewValue & 0x0F); else *b=(*b & 0x0F) | ((NewValue << 4) & 0xF0); } uint32_t Raster1D_4Bit::PTR_GetValue1D(const void *RAW_Data1D, unsigned x) const { const uint8_t *b = (uint8_t *)RAW_Data1D; if(x>=Size1D || RAW_Data1D==NULL) return 0; b += x >> 1; if(x & 1) return(*b & 0x0F); else return(*b >> 4); } #endif #ifdef OPTIMISE_SPEED void Raster1D_4Bit::Get(Raster1DAbstract &R1) const { switch(R1.GetPlanes()) { case 1: Conv4_1((uint8_t *)R1.Data1D,(const uint8_t *)Data1D,Size1D); return; // case 4: Raster1DAbstract::Get(R1); // return; case 8: Conv4_8((uint8_t *)R1.Data1D,(const uint8_t *)Data1D,Size1D); return; case 16:Conv4_16((uint16_t *)R1.Data1D,(const uint8_t *)Data1D,Size1D); return; case 24:Conv4_24((uint8_t *)R1.Data1D,(const uint8_t *)Data1D,Size1D); return; case 32:Conv4_32((uint32_t *)R1.Data1D,(const uint8_t *)Data1D,Size1D); return; #if defined(uint64_t_defined) case 64:Conv4_64((uint64_t *)R1.Data1D,(const uint8_t *)Data1D,Size1D); return; #endif } Raster1DAbstract::Get(R1); } void Raster1D_4Bit::Set(const Raster1DAbstract &R1) { switch(R1.GetPlanes()) { case 1: Conv1_4((uint8_t *)Data1D,(const uint8_t *)R1.Data1D,Size1D); return; // case 4: Raster1DAbstract::Set(R1); // return; case 8: Conv8_4((uint8_t *)Data1D,(const uint8_t *)R1.Data1D,Size1D); return; case 16:Conv16_4((uint8_t *)Data1D,(const uint16_t *)R1.Data1D,Size1D); return; case 24: Conv24_4((uint8_t *)Data1D,(const uint8_t *)R1.Data1D,Size1D); return; case 32:Conv32_4((uint8_t *)Data1D,(const uint32_t *)R1.Data1D,Size1D); return; } Raster1DAbstract::Set(R1); } #endif // OPTIMISE_SPEED /* -------------- 8 bit planes ---------------- */ #ifdef OPTIMISE_SPEED void Raster1D_8Bit::Get(Raster1DAbstract &R1) const { int i; signed char shift; i = R1.GetPlanes(); switch(i) { case 1: Conv8_1((uint8_t *)R1.Data1D,(const uint8_t*)Data1D,Size1D); return; case 4: Conv8_4((uint8_t *)R1.Data1D,(const uint8_t*)Data1D,Size1D); return; case 8: Raster1DAbstract::Get(R1); return; case 16:Conv8_16((uint16_t *)R1.Data1D,(const uint8_t*)Data1D,Size1D); return; case 24:Conv8_24((uint8_t *)R1.Data1D,(const uint8_t*)Data1D,Size1D); return; case 32:Conv8_32((uint32_t *)R1.Data1D,(const uint8_t*)Data1D,Size1D); return; #if defined(uint64_t_defined) case 64:Conv8_64((uint64_t *)R1.Data1D,(const uint8_t*)Data1D,Size1D); return; #endif } if(i<=0) { Raster1DAbstract::Get(R1); return; } const uint8_t *N_Buffer8Bit = (const uint8_t *)Data1D; shift = i - 8; if(shift>0) for(i=0;i> shift); } } } void Raster1D_8Bit::Set(const Raster1DAbstract &R1) { signed char shift; int i; i = R1.GetPlanes(); switch(i) { case 1: Conv1_8((uint8_t *)Data1D,(const uint8_t *)R1.Data1D,Size1D); return; #ifdef OPTIMISE_SPEED case 2: Conv2_8((uint8_t *)Data1D,(const uint8_t *)R1.Data1D,Size1D); return; #endif case 4: Conv4_8((uint8_t *)Data1D,(const uint8_t *)R1.Data1D,Size1D); return; case 8: Raster1DAbstract::Set(R1); return; case 16:Conv16_8((uint8_t *)Data1D,(const uint16_t *)R1.Data1D,Size1D); return; case 24:Conv24_8((uint8_t *)Data1D,(const uint8_t *)R1.Data1D,Size1D); return; case 32:Conv32_8((uint8_t *)Data1D,(const uint32_t *)R1.Data1D,Size1D); return; #if defined(uint64_t_defined) && defined(Conv64_8) case 64:Conv64_8((uint8_t *)Data1D,(const uint64_t *)R1.Data1D,Size1D); return; #endif } if(i<=0) { Raster1DAbstract::Set(R1); return; } uint8_t *N_Buffer8Bit = (uint8_t *)Data1D; shift = 8-i; if(shift>0) { for(i=0;i> shift; } } } void Raster1D_8Bit::Peel1Bit(void *Buffer1Bit, uint8_t plane) const { if(plane>=8) { if(Buffer1Bit!=NULL) memset(Buffer1Bit,0,(Size1D+7)/8); } else Peel1BitNStep((uint8_t*)Buffer1Bit, (const uint8_t*)Data1D, Size1D, 0x100|plane); } void Raster1D_8Bit::Join1Bit(const void *Buffer1Bit, uint8_t plane) { if(plane<8) Join1BitNStep((const uint8_t*)Buffer1Bit,(uint8_t*)Data1D,Size1D,0x100|plane); } void Raster1D_8Bit::Peel8Bit(void *Buffer8Bit, uint8_t plane8) const { if(plane8!=0) Raster1DAbstract::Peel8Bit(Buffer8Bit,plane8); else { if(Buffer8Bit!=NULL) memcpy(Buffer8Bit,Data1D,Size1D); } } void Raster1D_8Bit::Join8Bit(const void *Buffer8Bit, uint8_t plane8) { if(plane8!=0) Raster1DAbstract::Join8Bit(Buffer8Bit,plane8); else { if(Buffer8Bit!=NULL) memcpy(Data1D, Buffer8Bit,Size1D); } } #endif // OPTIMISE_SPEED void Raster1D_8Bit::SetValue1D(unsigned x, uint32_t NewValue) { if(Size1D0xFF) NewValue = 0xFF; ((uint8_t *)Data1D)[x] = (uint8_t)NewValue; } uint32_t Raster1D_8Bit::GetValue1D(unsigned x) const { if(x>=Size1D) return 0; return ((uint8_t *)Data1D)[x]; } #ifdef _REENTRANT void Raster1D_8Bit::PTR_SetValue1D(void *RAW_Data1D, unsigned x, uint32_t NewValue) const { if(Size1D0xFF) NewValue = 0xFF; ((uint8_t *)RAW_Data1D)[x] = (uint8_t)NewValue; } uint32_t Raster1D_8Bit::PTR_GetValue1D(const void *RAW_Data1D, unsigned x) const { if(x>=Size1D || RAW_Data1D==NULL) return(0); return(((uint8_t *)RAW_Data1D)[x]); } void Raster1D_8Bit::PTR_SetValue1Dd(void *RAW_Data1D, unsigned x, double NewValue) const { if(Size1D0xFF) NewValue = 0xFF; ((uint8_t *)RAW_Data1D)[x] = (uint8_t)NewValue; } double Raster1D_8Bit::PTR_GetValue1Dd(const void *RAW_Data1D, unsigned x) const { if(x>=Size1D || RAW_Data1D==NULL) return(0); return(((uint8_t *)RAW_Data1D)[x]); } #endif /* ------------- 16 bit planes -------------- */ #ifdef _REENTRANT uint32_t Raster1D_16Bit::PTR_GetValue1D(const void *RAW_Data1D, unsigned x) const { if(RAW_Data1D==NULL || Size1D<=x) return(0); return(((uint16_t *)RAW_Data1D)[x]); } void Raster1D_16Bit::PTR_SetValue1D(void *RAW_Data1D, unsigned x, uint32_t NewValue) const { if(RAW_Data1D==NULL || Size1D<=x) return; ((uint16_t *)RAW_Data1D)[x] = NewValue; } double Raster1D_16Bit::PTR_GetValue1Dd(const void *RAW_Data1D, unsigned x) const { if(RAW_Data1D==NULL || Size1D<=x) return(0); return(((uint16_t *)RAW_Data1D)[x]); } void Raster1D_16Bit::PTR_SetValue1Dd(void *RAW_Data1D, unsigned x, double NewValue) const { if(RAW_Data1D==NULL || Size1D<=x) return; ((uint16_t *)RAW_Data1D)[x] = NewValue; } #endif #ifdef OPTIMISE_SPEED void Raster1D_16Bit::Get(Raster1DAbstract &R1) const { int i; signed char shift; i = R1.GetPlanes(); switch(i) { case 1: Conv16_1((uint8_t *)R1.Data1D,(const uint16_t *)Data1D,Size1D); return; case 4: Conv16_4((uint8_t *)R1.Data1D,(const uint16_t *)Data1D,Size1D); return; case 8: Conv16_8((uint8_t *)R1.Data1D,(const uint16_t *)Data1D,Size1D); return; case 16:Raster1DAbstract::Get(R1); return; case 24:Conv16_24((uint8_t *)R1.Data1D,(const uint16_t *)Data1D,Size1D); return; case 32:Conv16_32((uint32_t *)R1.Data1D,(const uint16_t *)Data1D,Size1D); return; #if defined(uint64_t_defined) case 64:Conv16_64((uint64_t *)R1.Data1D,(const uint16_t *)Data1D,Size1D); return; #endif } if(i<=0) { Raster1DAbstract::Get(R1); return; } shift = i - 16; const uint16_t *N_Buffer16Bit = (const uint16_t *)Data1D; if(shift>0) for(i=0;i> shift); } } } void Raster1D_16Bit::Set(const Raster1DAbstract &R1) { int i; signed char shift; i = R1.GetPlanes(); switch(i) { case 1: Conv1_16((uint16_t *)Data1D,(const uint8_t *)R1.Data1D,Size1D); return; #ifdef OPTIMISE_SPEED case 2: Conv2_16((uint16_t *)Data1D,(const uint8_t *)R1.Data1D,Size1D); return; #endif case 4: Conv4_16((uint16_t *)Data1D,(const uint8_t *)R1.Data1D,Size1D); return; case 8: Conv8_16((uint16_t *)Data1D,(const uint8_t *)R1.Data1D,Size1D); return; case 16:Raster1DAbstract::Set(R1); return; case 24:Conv24_16((uint16_t *)Data1D,(const uint8_t *)R1.Data1D,Size1D); return; case 32:Conv32_16((uint16_t *)Data1D,(const uint32_t *)R1.Data1D,Size1D); return; #if defined(uint64_t_defined) case 64:Conv64_16((uint16_t *)Data1D,(const uint64_t *)R1.Data1D,Size1D); return; #endif } if(i<=0) { Raster1DAbstract::Set(R1); return; } shift = 16 - i; uint16_t *N_Buffer16Bit = (uint16_t *)Data1D; if(shift>0) for(i=0;i> shift; } } } void Raster1D_16Bit::Peel1Bit(void *Buffer1Bit, uint8_t plane) const { if(plane>=16) { if(Buffer1Bit!=NULL) memset(Buffer1Bit,0,(Size1D+7)/8); } else { #ifdef HI_ENDIAN if(plane<8) Peel1BitNStep((uint8_t*)Buffer1Bit, 1+(const uint8_t*)Data1D, Size1D, 0x200|plane); else Peel1BitNStep((uint8_t*)Buffer1Bit, (const uint8_t*)Data1D, Size1D, 0x200|(plane-8)); #else #ifdef LO_ENDIAN Peel1BitNStep((uint8_t*)Buffer1Bit, (plane>>3)+(const uint8_t*)Data1D, Size1D, 0x200|(plane%8)); #else Raster1DAbstract::Peel1Bit(Buffer1Bit,plane); // ?? Unspecified endian, use default. #endif #endif } } void Raster1D_16Bit::Join1Bit(const void *Buffer1Bit, uint8_t plane) { if(plane<16) { #ifdef HI_ENDIAN Join1BitNStep((const uint8_t*)Buffer1Bit,(1-(plane>>3))+(uint8_t*)Data1D,Size1D,0x200|(plane%8)); #else #ifdef LO_ENDIAN Join1BitNStep((const uint8_t*)Buffer1Bit,(plane>>3)+(uint8_t*)Data1D,Size1D,0x200|(plane%8)); #else Raster1DAbstract::Join1Bit(Buffer1Bit,plane); // ?? #endif #endif } } #endif // OPTIMISE_SPEED /* Raster1D_16BitIDX::Raster1D_16BitIDX(int InitSize1D, Raster1DAbstractRGB *newPalette): Raster1D_16Bit(InitSize1D) { pPalette = newPalette; if(pPalette!=NULL) pPalette->UsageCount++; } Raster1D_16BitIDX::~Raster1D_16BitIDX() { if(pPalette!=NULL) { if(InterlockedDecrement(&pPalette->UsageCount)<=0) delete(pPalette); pPalette = NULL; } } void Raster1D_16BitIDX::Set(const Raster1DAbstract &R1) { if(pPalette!=NULL && R1.Channels()>=4 && Data1D!=NULL) { int maxi = Size1D>R1.Size1D?Size1D:R1.Size1D; uint32_t val; while(maxi-- > 0) { val = GetValue1D(maxi); // Indexed Val; R1.SetValue1D(maxi,val); } } else Raster1D_16Bit::Set(R1); } */ /* ------------ 24 bit planes Gray ------------ */ void Raster1D_24Bit::SetValue1D(unsigned x, uint32_t NewValue) { uint8_t *BuffPos; if(x>=Size1D) return; BuffPos=((uint8_t *)Data1D)+(3*x); *BuffPos++=NewValue & 0xFF; NewValue >>= 8; *BuffPos++=NewValue & 0xFF; NewValue >>= 8; *BuffPos=NewValue & 0xFF; } uint32_t Raster1D_24Bit::GetValue1D(unsigned x) const { const uint8_t *b; if(x>=Size1D || Data1D==NULL) return(0); b = (uint8_t *)Data1D + 3*x; return((uint32_t)*b | (uint32_t)b[1]<<8 | (uint32_t)b[2]<<16); } #ifdef _REENTRANT uint32_t Raster1D_24Bit::PTR_GetValue1D(const void *RAW_Data1D,unsigned x) const { const uint8_t *b; if(x>=Size1D || RAW_Data1D==NULL) return(0); b = (uint8_t *)RAW_Data1D + 3*x; return((uint32_t)*b | (uint32_t)b[1]<<8 | (uint32_t)b[2]<<16); } void Raster1D_24Bit::PTR_SetValue1D(void *RAW_Data1D, unsigned x, uint32_t NewValue) const { uint8_t *BuffPos; if(x>=Size1D || RAW_Data1D==NULL) return; BuffPos = ((uint8_t *)RAW_Data1D)+(3*x); *BuffPos++=NewValue & 0xFF; NewValue >>= 8; *BuffPos++=NewValue & 0xFF; NewValue >>= 8; *BuffPos=NewValue & 0xFF; } #endif #ifdef OPTIMISE_SPEED void Raster1D_24Bit::Get(Raster1DAbstract &R1) const { switch(R1.GetPlanes()) { case 1: Conv24_1((uint8_t *)R1.Data1D,(const uint8_t *)Data1D,Size1D); return; case 4: Conv24_4((uint8_t *)R1.Data1D,(const uint8_t *)Data1D,Size1D); return; case 8: Conv24_8((uint8_t *)R1.Data1D,(const uint8_t *)Data1D,Size1D); return; case 16:Conv24_16((uint16_t *)R1.Data1D,(const uint8_t *)Data1D,Size1D); return; case 32:Conv24_32((uint32_t *)R1.Data1D,(const uint8_t *)Data1D,Size1D); return; #if defined(uint64_t_defined) case 64:Conv24_64((uint64_t *)R1.Data1D,(const uint8_t *)Data1D,Size1D); return; #endif } Raster1DAbstract::Get(R1); } void Raster1D_24Bit::Set(const Raster1DAbstract &R1) { switch(R1.GetPlanes()) { case 1: Conv1_24((uint8_t *)Data1D,(const uint8_t *)R1.Data1D,Size1D); return; case 2: Conv2_24((uint8_t *)Data1D,(const uint8_t *)R1.Data1D,Size1D); return; case 4: Conv4_24((uint8_t *)Data1D,(const uint8_t *)R1.Data1D,Size1D); return; case 8: Conv8_24((uint8_t *)Data1D,(const uint8_t *)R1.Data1D,Size1D); return; case 16:Conv16_24((uint8_t *)Data1D,(const uint16_t *)R1.Data1D,Size1D); return; case 32:Conv32_24((uint8_t *)Data1D,(const uint32_t *)R1.Data1D,Size1D); return; #if defined(uint64_t_defined) case 64:Conv64_24((uint8_t *)Data1D,(const uint64_t *)R1.Data1D,Size1D); return; #endif } Raster1DAbstract::Set(R1); } void Raster1D_24Bit::Peel1Bit(void *Buffer1Bit, uint8_t plane) const { if(plane>=24) { if(Buffer1Bit!=NULL) memset(Buffer1Bit,0,(Size1D+7)/8); } else { Peel1BitNStep((uint8_t*)Buffer1Bit, (plane>>3)+(const uint8_t*)Data1D, Size1D, 0x300|(plane%8)); } } void Raster1D_24Bit::Join1Bit(const void *Buffer1Bit, uint8_t plane) { if(plane<24) { Join1BitNStep((const uint8_t*)Buffer1Bit,(plane>>3)+(uint8_t*)Data1D,Size1D,0x300|(plane%8)); } } #endif // OPTIMISE_SPEED void Raster1D_24Bit::Peel8Bit(void *Buffer8Bit, uint8_t plane8) const { if((plane8 & 0x3)!=0 || plane8>16) {Raster1DAbstract::Peel8Bit(Buffer8Bit,plane8); return;} Peel8BitNStep((uint8_t*)Buffer8Bit, (plane8>>3)+(const uint8_t*)Data1D, Size1D, 3); } void Raster1D_24Bit::Join8Bit(const void *Buffer8Bit, uint8_t plane8) { if((plane8 & 0x3)!=0 || plane8>16) {Raster1DAbstract::Join8Bit(Buffer8Bit,plane8); return;} Join8BitNStep((const uint8_t*)Buffer8Bit, (plane8>>3)+(uint8_t*)Data1D, Size1D, 3); } void Raster1D_24Bit::Get24BitRGB(void *Buffer24Bit) const { memcpy(Buffer24Bit,Data1D,3*Size1D); } /* ------------ 32 bit planes -------------- */ void Raster1D_32Bit::SetValue1Dd(unsigned x, double NewValue) { if(x>=Size1D) return; if(NewValue>(double)0xFFFFFFFF) //overflow check ((uint32_t *)Data1D)[x] = 0xFFFFFFFFl; else ((uint32_t *)Data1D)[x] = NewValue; } #ifdef _REENTRANT uint32_t Raster1D_32Bit::PTR_GetValue1D(const void *RAW_Data1D, unsigned x) const { if(RAW_Data1D==NULL || Size1D<=x) return(0); return(((uint32_t *)RAW_Data1D)[x]); } void Raster1D_32Bit::PTR_SetValue1D(void *RAW_Data1D, unsigned x, uint32_t NewValue) const { if(RAW_Data1D==NULL || Size1D<=x) return; ((uint32_t *)RAW_Data1D)[x] = NewValue; } void Raster1D_32Bit::PTR_SetValue1Dd(void *RAW_Data1D, unsigned x, double NewValue) const { if(RAW_Data1D==NULL || x>=Size1D) return; if(NewValue>(double)0xFFFFFFFF) //overflow check ((uint32_t *)RAW_Data1D)[x] = 0xFFFFFFFFl; else ((uint32_t *)RAW_Data1D)[x] = NewValue; } #endif /* void Raster1DAbstract::Get32Bit(void *Buffer32Bit) const { uint32_t *N_Buffer32Bit = (uint32_t *)Buffer32Bit; int i; for(i=0;i0) for(unsigned i=0;i> shift); } } } void Raster1D_32Bit::Set(const Raster1DAbstract &R1) { signed char shift; signed char p = R1.GetPlanes(); switch(p) { case 1: Conv1_32((uint32_t *)Data1D,(const uint8_t *)R1.Data1D,Size1D); return; #ifdef OPTIMISE_SPEED case 2: Conv2_32((uint32_t *)Data1D,(const uint8_t *)R1.Data1D,Size1D); return; #endif case 4: Conv4_32((uint32_t *)Data1D,(const uint8_t *)R1.Data1D,Size1D); return; case 8: Conv8_32((uint32_t *)Data1D,(const uint8_t *)R1.Data1D,Size1D); return; case 16:Conv16_32((uint32_t *)Data1D,(const uint16_t *)R1.Data1D,Size1D); return; case 24:Conv24_32((uint32_t *)Data1D,(const uint8_t *)R1.Data1D,Size1D); return; case 32:Raster1DAbstract::Set(R1); return; #if defined(uint64_t_defined) case 64:Conv64_32((uint32_t *)Data1D,(const uint64_t *)R1.Data1D,Size1D); return; #endif } if(p<0) { Raster1DAbstract::Set(R1); return; } uint32_t *N_Buffer32Bit = (uint32_t *)Data1D; shift = 32 - p; if(shift>0) for(unsigned i=0;i> shift; } } } void Raster1D_32Bit::Peel1Bit(void *Buffer1Bit, uint8_t plane) const { if(plane>=32) { if(Buffer1Bit!=NULL) memset(Buffer1Bit,0,(Size1D+7)/8); } else { #ifdef HI_ENDIAN Peel1BitNStep((uint8_t*)Buffer1Bit, (3-(plane>>3))+(const uint8_t*)Data1D, Size1D, 0x400|(plane%8)); #else #ifdef LO_ENDIAN Peel1BitNStep((uint8_t*)Buffer1Bit, (plane>>3)+(const uint8_t*)Data1D, Size1D, 0x400|(plane%8)); #else Raster1DAbstract::Peel1Bit(Buffer1Bit,plane); // ?? Unspecified endian, use default. #endif #endif } } void Raster1D_32Bit::Join1Bit(const void *Buffer1Bit, uint8_t plane) { if(plane<32) { #ifdef HI_ENDIAN Join1BitNStep((const uint8_t*)Buffer1Bit,(3-(plane>>3))+(uint8_t*)Data1D,Size1D,0x400|(plane%8)); #else #ifdef LO_ENDIAN Join1BitNStep((const uint8_t*)Buffer1Bit,(plane>>3)+(uint8_t*)Data1D,Size1D,0x400|(plane%8)); #else Raster1DAbstract::Join1Bit(Buffer1Bit,plane); // ?? #endif #endif } } #endif // OPTIMISE_SPEED void Raster1D_32Bit::Peel8Bit(void *Buffer8Bit, uint8_t plane8) const { if((plane8 & 0x3)!=0 || plane8>24) {Raster1DAbstract::Peel8Bit(Buffer8Bit,plane8); return;} #ifdef HI_ENDIAN Peel8BitNStep((uint8_t*)Buffer8Bit, (3-(plane8>>3))+(const uint8_t*)Data1D, Size1D, 4); #else #ifdef LO_ENDIAN Peel8BitNStep((uint8_t*)Buffer8Bit, (plane8>>3)+(const uint8_t*)Data1D, Size1D, 4); #else Raster1DAbstract::Peel8Bit(Buffer8Bit,plane8); #endif #endif } void Raster1D_32Bit::Join8Bit(const void *Buffer8Bit, uint8_t plane8) { if((plane8 & 0x3)!=0 || plane8>24) {Raster1DAbstract::Join8Bit(Buffer8Bit,plane8); return;} #ifdef HI_ENDIAN Join8BitNStep((const uint8_t*)Buffer8Bit, (3-(plane8>>3))+(uint8_t*)Data1D, Size1D, 4); #else #ifdef LO_ENDIAN Join8BitNStep((const uint8_t*)Buffer8Bit, (plane8>>3)+(uint8_t*)Data1D, Size1D, 4); #else Raster1DAbstract::Join8Bit(Buffer8Bit,plane8); #endif #endif } /* ------------ 64 bit planes -------------- */ #if defined(uint64_t_defined) uint32_t Raster1D_64Bit::GetValue1D(unsigned x) const { if(x>=Size1D) return 0; const uint64_t q = ((uint64_t *)Data1D)[x]; return((uint32_t)(q>>32)); }; void Raster1D_64Bit::SetValue1D(unsigned x, uint32_t NewValue) { if(x=Size1D) return; if(NewValue>(double)_UI64_MAX) ((uint64_t *)Data1D)[x] = (uint64_t)_UI64_MAX; else ((uint64_t *)Data1D)[x] = (uint64_t)NewValue; } #ifdef _REENTRANT uint32_t Raster1D_64Bit::PTR_GetValue1D(const void *RAW_Data1D, unsigned x) const { if(RAW_Data1D==NULL || Size1D<=x) return(0); return(((uint64_t *)RAW_Data1D)[x]>>32); } double Raster1D_64Bit::PTR_GetValue1Dd(const void *RAW_Data1D, unsigned x) const { if(RAW_Data1D==NULL || Size1D<=x) return(0); return(((uint64_t *)RAW_Data1D)[x]); } void Raster1D_64Bit::PTR_SetValue1D(void *RAW_Data1D, unsigned x, uint32_t NewValue) const { if(RAW_Data1D==NULL || Size1D<=x) return; ((uint64_t *)RAW_Data1D)[x] = NewValue * #ifdef __BORLANDC__ (uint64_t)0x0000000100000001ui64; #else (uint64_t)0x0000000100000001ll; #endif } void Raster1D_64Bit::PTR_SetValue1Dd(void *RAW_Data1D, unsigned x, double NewValue) const { if(RAW_Data1D==NULL || x>=Size1D) return; if(NewValue>(double)_UI64_MAX) ((uint64_t *)RAW_Data1D)[x] = (uint64_t)_UI64_MAX; else ((uint64_t *)RAW_Data1D)[x] = (uint64_t)NewValue; } #endif void Raster1D_64Bit::Peel1Bit(void *Buffer1Bit, uint8_t plane) const { if(plane>=64) { if(Buffer1Bit!=NULL) memset(Buffer1Bit,0,(Size1D+7)/8); } else { #ifdef HI_ENDIAN Peel1BitNStep((uint8_t*)Buffer1Bit, (7-(plane>>3))+(const uint8_t*)Data1D, Size1D, 0x800|(plane%8)); #else #ifdef LO_ENDIAN Peel1BitNStep((uint8_t*)Buffer1Bit, (plane>>3)+(const uint8_t*)Data1D, Size1D, 0x800|(plane%8)); #else Raster1DAbstract::Peel1Bit(Buffer1Bit,plane); // ?? Unspecified endian, use default. #endif #endif } } void Raster1D_64Bit::Join1Bit(const void *Buffer1Bit, uint8_t plane) { if(plane<64) { #ifdef HI_ENDIAN Join1BitNStep((const uint8_t*)Buffer1Bit,(7-(plane>>3))+(uint8_t*)Data1D,Size1D,0x800|(plane%8)); #else #ifdef LO_ENDIAN Join1BitNStep((const uint8_t*)Buffer1Bit,(plane>>3)+(uint8_t*)Data1D,Size1D,0x800|(plane%8)); #else Raster1DAbstract::Join1Bit(Buffer1Bit,plane); // ?? #endif #endif } } void Raster1D_64Bit::Peel8Bit(void *Buffer8Bit, uint8_t plane8) const { if((plane8 & 0x3)!=0 || plane8>56) {Raster1DAbstract::Peel8Bit(Buffer8Bit,plane8); return;} #ifdef HI_ENDIAN Peel8BitNStep((uint8_t*)Buffer8Bit, (7-(plane8>>3))+(const uint8_t*)Data1D, Size1D, 8); #else #ifdef LO_ENDIAN Peel8BitNStep((uint8_t*)Buffer8Bit, (plane8>>3)+(const uint8_t*)Data1D, Size1D, 8); #else Raster1DAbstract::Peel8Bit(Buffer8Bit,plane8); #endif #endif } void Raster1D_64Bit::Join8Bit(const void *Buffer8Bit, uint8_t plane8) { if((plane8 & 0x3)!=0 || plane8>56) {Raster1DAbstract::Join8Bit(Buffer8Bit,plane8); return;} #ifdef HI_ENDIAN Join8BitNStep((const uint8_t*)Buffer8Bit, (7-(plane8>>3))+(uint8_t*)Data1D, Size1D, 8); #else #ifdef LO_ENDIAN Join8BitNStep((const uint8_t*)Buffer8Bit, (plane8>>3)+(uint8_t*)Data1D, Size1D, 8); #else Raster1DAbstract::Join8Bit(Buffer8Bit,plane8); #endif #endif } #ifdef OPTIMISE_SPEED void Raster1D_64Bit::Get(Raster1DAbstract &R1) const { switch(R1.GetPlanes()) { #ifdef Conv64_1 case 1: Conv64_1((uint8_t *)R1.Data1D,(const uint64_t *)Data1D,Size1D); return; #endif #ifdef Conv64_8 case 8: Conv64_8((uint8_t *)R1.Data1D,(const uint64_t *)Data1D,Size1D); return; #endif case 16:Conv64_16((uint16_t *)R1.Data1D,(const uint64_t *)Data1D,Size1D); return; case 24:Conv64_24((uint8_t *)R1.Data1D,(const uint64_t *)Data1D,Size1D); return; case 32:Conv64_32((uint32_t *)R1.Data1D,(const uint64_t *)Data1D,Size1D); return; } Raster1DAbstract::Get(R1); } void Raster1D_64Bit::Set(const Raster1DAbstract &R1) { switch(R1.GetPlanes()) { case 1: Conv1_64((uint64_t *)Data1D,(const uint8_t *)R1.Data1D,Size1D); return; case 4: Conv4_64((uint64_t *)Data1D,(const uint8_t *)R1.Data1D,Size1D); return; case 8: Conv8_64((uint64_t *)Data1D,(const uint8_t *)R1.Data1D,Size1D); return; case 16:Conv16_64((uint64_t *)Data1D,(const uint16_t *)R1.Data1D,Size1D); return; case 24:Conv24_64((uint64_t *)Data1D,(const uint8_t *)R1.Data1D,Size1D); return; case 32:Conv32_64((uint64_t *)Data1D,(const uint32_t *)R1.Data1D,Size1D); return; } Raster1DAbstract::Set(R1); } #endif #endif /* ------------ 32 bit planes FLOAT -------------- */ uint32_t Raster1D_32FltBit::GetValue1D(unsigned x) const { if(x>=Size1D) return 0; return((((float *)Data1D)[x] - Min)*(Max-Min)); }; double Raster1D_32FltBit::GetValue1Dd(unsigned x) const { if(x>=Size1D) return 0; return(((float *)Data1D)[x]); }; void Raster1D_32FltBit::SetValue1D(unsigned x, uint32_t NewValue) { if(x>=Size1D) return; ((float *)Data1D)[x] = Min + (float)NewValue/(Max-Min); return; } void Raster1D_32FltBit::SetValue1Dd(unsigned x, double NewValue) { if(x>=Size1D) return; ((float *)Data1D)[x] = NewValue; return; } #ifdef _REENTRANT uint32_t Raster1D_32FltBit::PTR_GetValue1D(const void *RAW_Data1D, unsigned x) const { if(x>=Size1D) return 0; return((((float *)RAW_Data1D)[x] - Min)*(Max-Min)); }; double Raster1D_32FltBit::PTR_GetValue1Dd(const void *RAW_Data1D, unsigned x) const { if(x>=Size1D) return 0; return(((float *)RAW_Data1D)[x]); }; void Raster1D_32FltBit::PTR_SetValue1D(void *RAW_Data1D, unsigned x, uint32_t NewValue) const { if(x>=Size1D) return; ((float *)RAW_Data1D)[x] = Min + (float)NewValue/(Max-Min); return; } void Raster1D_32FltBit::PTR_SetValue1Dd(void *RAW_Data1D, unsigned x, double NewValue) const { if(x>=Size1D) return; ((float *)RAW_Data1D)[x] = NewValue; return; } #endif #ifdef OPTIMISE_SPEED void Raster1D_32FltBit::Get(Raster1DAbstract &R1) const { const float *N_BufferFlt = (float *)Data1D; int i; i = R1.GetPlanes(); if(i<0) // Float or double. { if(i==-32) memcpy(R1.Data1D, Data1D, Size1D*sizeof(float)); else { for(i=0; i0) R1.SetValue1Dd(i,*N_BufferFlt); else R1.SetValue1D(i,0); N_BufferFlt++; } } } void Raster1D_32FltBit::Set(const Raster1DAbstract &R1) { float *N_BufferFlt = (float *)Data1D; int i; i = R1.GetPlanes(); if(i<0) // Float or double. { if(i==-32) memcpy(Data1D, R1.Data1D, Size1D*sizeof(float)); else { for(i=0; i32) for(i=0; i=Size1D) return 0; return((((double *)Data1D)[x] - Min)*(Max-Min)); } void Raster1D_64FltBit::SetValue1D(unsigned x, uint32_t NewValue) { if(x>=Size1D) return; ((double *)Data1D)[x] = Min + (double)NewValue/(Max-Min); return; } double Raster1D_64FltBit::GetValue1Dd(unsigned x) const { if(x>=Size1D) return 0; return(((double *)Data1D)[x]); } void Raster1D_64FltBit::SetValue1Dd(unsigned x, double NewValue) { if(x>=Size1D) return; ((double *)Data1D)[x] = NewValue; return; } #ifdef _REENTRANT uint32_t Raster1D_64FltBit::PTR_GetValue1D(const void *RAW_Data1D, unsigned x) const { if(x>=Size1D) return 0; return((((double *)RAW_Data1D)[x] - Min)*(Max-Min)); } /// Must be consistent with Raster1D_64FltBit::GetValue1Dd double Raster1D_64FltBit::PTR_GetValue1Dd(const void *RAW_Data1D, unsigned x) const { if(x>=Size1D) return 0; return(((double *)RAW_Data1D)[x]); } void Raster1D_64FltBit::PTR_SetValue1D(void *RAW_Data1D, unsigned x, uint32_t NewValue) const { if(x>=Size1D) return; ((double *)RAW_Data1D)[x] = Min + (double)NewValue/(Max-Min); return; } void Raster1D_64FltBit::PTR_SetValue1Dd(void *RAW_Data1D, unsigned x, double NewValue) const { if(x>=Size1D) return; ((double *)RAW_Data1D)[x] = NewValue; return; } #endif #ifdef OPTIMISE_SPEED void Raster1D_64FltBit::Get(Raster1DAbstract &R1) const { const double *N_BufferFlt = (const double *)Data1D; const int i = R1.GetPlanes(); const uint32_t MaxVal = (i<0) ? 0 : ((1<Allocate1D(Size1D); if(Raster->Data1D==NULL) { delete Raster; return(NULL); } } } return(Raster); } /* ------ */ void Raster1DAbstractRGB::Get(Raster1DAbstract &R1) const { int maxi; signed char shift; if(Data1D==NULL || R1.Data1D==NULL) return; const int R1_channels = R1.Channels(); signed char R1_Planes = R1.GetPlanes(); if(R1_Planes==16 && R1_channels==3) R1_Planes=24; // RGB565 is converted to 8 bits. signed char Planes = GetPlanes(); if(Planes==16) Planes=24; // RGB565 is converted to 8 bits. maxi = (R1.Size1D>Size1D) ? Size1D : R1.Size1D; shift = R1_Planes/R1_channels - Planes/3; if(shift==0 || Planes<0 || R1_Planes<0) // No bitplane change - copy data only { switch(R1_channels) { case 1: while(maxi-- > 0) // convert from RGB to gray { R1.SetValue1D(maxi, (R(maxi)+G(maxi)+B(maxi))/3); } return; case 3: // convert float RGB to int RGB if(GetPlanes()==R1.GetPlanes()) // check same sign. memcpy(R1.Data1D, Data1D, ((long)maxi*labs(GetPlanes())+7)/8); // convert from RGB to RGB - just copy // fallback to 4 case 4: { RGBQuad RGB; RGB.O = 0; while(maxi-- > 0) // convert from RGB to RGBA { RGB.R = R(maxi); RGB.G = G(maxi); RGB.B = B(maxi); R1.Set(maxi,&RGB); } return; } } } if(shift>0) { RGBQuad RGB; while(maxi-- > 0) { Get(maxi,&RGB); RGB.R<<=shift; RGB.G<<=shift; RGB.B<<=shift; R1.Set(maxi,&RGB); } return; } else { RGBQuad RGB; shift = -shift; while(maxi-- > 0) { Get(maxi,&RGB); RGB.R>>=shift; RGB.G>>=shift; RGB.B>>=shift; R1.Set(maxi,&RGB); } return; } } /** Copy data from a given container. */ void Raster1DAbstractRGB::Set(const Raster1DAbstract &R1) { int maxi; signed char shift; if(Data1D==NULL || R1.Data1D==NULL) return; const int R1_channels = R1.Channels(); signed char R1_Planes = R1.GetPlanes(); if(R1_Planes==16 && R1_channels==3) R1_Planes=24; // RGB565 is converted to 8 bits. signed char Planes = GetPlanes(); if(Planes==16) Planes=24; // RGB565 is converted to 8 bits. maxi = (Size1D>R1.Size1D) ? Size1D : R1.Size1D; shift = Planes/3 - R1_Planes/R1_channels; if(shift==0 || Planes<0 || R1_Planes<0) // No bitplane change - copy data only { switch(R1_channels) { case 1: while(maxi-- > 0) // convert from gray to RGB { const uint32_t val = R1.GetValue1D(maxi); setR(maxi,val); setG(maxi,val); setB(maxi,val); } return; case 3: if(GetPlanes()==R1.GetPlanes()) // check same sign and same native planes. { memcpy(Data1D, R1.Data1D, ((long)maxi*labs(GetPlanes())+7)/8); // convert from RGB to RGB - just copy return; } // fallback (no break) convert float RGB to int RGB case 4:{ RGBQuad RGB; while(maxi-- > 0) // convert from RGBA to RGB { R1.Get(maxi,&RGB); Set(maxi,&RGB); } return; } } } if(shift>0) { RGBQuad RGB; while(maxi-- > 0) { R1.Get(maxi,&RGB); setR(maxi,RGB.R< 0) { R1.Get(maxi,&RGB); setR(maxi,RGB.R>>shift); setG(maxi,RGB.G>>shift); setB(maxi,RGB.B>>shift); } return; } } void Raster1DAbstractRGB::Set(const Raster1DAbstract &R1, const Raster1DAbstract &Palette) { int maxi; signed char shift = 0; uint32_t val; shift = GetPlanes()/Channels() - R1.GetPlanes()/R1.Channels(); maxi = Size1D>R1.Size1D?Size1D:R1.Size1D; if(shift>0) { while(maxi-- > 0) { val = R1.GetValue1D(maxi); val = Palette.GetValue1D(maxi); setR(maxi,val< 0) { val = R1.GetValue1D(maxi); val = Palette.GetValue1D(maxi); setR(maxi,val>>shift); setG(maxi,val>>shift); setB(maxi,val>>shift); } } } /** Copy data from a given container. */ void Raster1DAbstractRGBA::Set(const Raster1DAbstract &R1) { unsigned i, maxi; signed char shift; RGBQuad RGB; if(Data1D==NULL || R1.Data1D==NULL) return; memset(&RGB,0,sizeof(RGB)); maxi=Size1D>R1.Size1D?Size1D:R1.Size1D; shift = GetPlanes()/4 - R1.GetPlanes()/R1.Channels(); switch(R1.Channels()) { case 1: case 2: if(shift==0) // No bitplane change - copy data only { for(i=0;i0) { for(i=0;i> shift; Set(i,&RGB); } return; } case 3: if(shift==0) // No bitplane change - copy data only { for(i=0;i0) { for(i=0; i>= shift; RGB.G >>= shift; RGB.B >>= shift; Set(i,&RGB); } return; } case 4: if(shift==0) // No bitplane change - copy data only { i = Size1D; if(R1.Size1D0) { for(i=0;i>= shift; RGB.G >>= shift; RGB.B >>= shift; RGB.O >>= shift; Set(i,&RGB); } return; } } } void Raster1DAbstractRGB::Get(unsigned index, RGBQuad *RGB) const { if(RGB==NULL) return; RGB->R = R(index); RGB->G = G(index); RGB->B = B(index); } void Raster1DAbstractRGBA::Get(unsigned index, RGBQuad *RGB) const { if(RGB==NULL) return; RGB->R = R(index); RGB->G = G(index); RGB->B = B(index); RGB->O = A(index); } void Raster1DAbstractRGB::Set(unsigned index, const RGBQuad *RGB) { if(RGB==NULL) return; setR(index, RGB->R); setG(index, RGB->G); setB(index, RGB->B); } void Raster1DAbstractRGBA::Set(unsigned index, const RGBQuad *RGB) { if(RGB==NULL) return; setR(index, RGB->R); setG(index, RGB->G); setB(index, RGB->B); setA(index, RGB->O); } /* 16 bit planes for 3 channels R,G,B in geometry A1 R5 G5 B5 */ void Raster1D_16Bit565::Get(unsigned index, RGBQuad *RGB) const { if(RGB==NULL) return; if(Data1D==NULL || Size1DB = (val&0x1F) << 3; RGB->G = (val>>3) & 0xFC; // ((val>>5)&0x3F) << 2; RGB->R = (val>>8) & 0xF8; //((val>>11)&0x1F) << 2; RGB->O = 0; } void Raster1D_16Bit565::Set(unsigned index, const RGBQuad *RGB) { if(RGB==NULL || Data1D==NULL || Size1DB>>3) | ((RGB->G & 0xFC)<<3) | ((RGB->R & 0xF8)<<8); } uint32_t Raster1D_16Bit565::GetValue1DRAW(unsigned x) const { if(x >= 3*Size1D) return 0; uint32_t val = ((uint16_t *)Data1D)[x/3]; x %= 3; if(x==2) return (val&0x1F)<<3; // R if(x==1) return (val&0x07E0)>>3; // G return ((val&0xF800)>>8); // B } void Raster1D_16Bit565::SetValue1DRAW(unsigned x, uint32_t NewValue) { if(3*Size1D < x) return; uint16_t * const pVal = (x/3) + (uint16_t *)Data1D; switch(x%3) { case 0: *pVal = (*pVal & 0x07FF) | (0xF800 & (NewValue<<8)); break; // scale 5b to 8b case 1: *pVal = (*pVal & 0xF81F) | (0x07E0 & (NewValue<<3)); break; // scale 6b to 8b case 2: *pVal = (*pVal & 0xFFE0) | (0x001F & (NewValue>>3)); break; // scale 5b to 8b } } #ifdef _REENTRANT uint32_t Raster1D_16Bit565::PTR_GetValue1DRAW(const void *RAW_Data1D, unsigned x) const { if(x>=3*Size1D) return 0; uint32_t val = ((uint16_t *)RAW_Data1D)[x/3]; x %= 3; if(x==2) return (val&0x1F)<<3; // R if(x==1) return (val&0x07E0)>>3; // G return ((val&0xF800)>>8); // B } void Raster1D_16Bit565::PTR_SetValue1DRAW(void *RAW_Data1D, unsigned x, uint32_t NewValue) { if(RAW_Data1D==NULL || 3*Size1D>3)); break; // scale 5b to 8b } } #endif uint32_t Raster1D_16Bit565::GetValue1D(unsigned x) const { if(x>=Size1D) return 0; uint32_t val = ((uint16_t *)Data1D)[x]; //return ((255*(val&0x1F)/31)<<16) | ((255*((val>>5)&0x1F)/31)<<8) | (255*((val>>10)&0x1F)/31); return ((val&0x1F)<<19) | ((val&0x7E0)<<5) | ((val&0xF800)>>8); } void Raster1D_16Bit565::SetValue1D(unsigned x, uint32_t NewValue) { if(Size1D<=x) return; ((uint16_t *)Data1D)[x] = (uint16_t)(((NewValue&0xF8)<<8) | ((NewValue&0xFC00)>>5) | ((NewValue&0xF80000)>>19)); } /* void Raster1D_16BitA1R5G5B5:Get24BitRGB(void *Buffer24Bit) const { } */ uint32_t Raster1D_16Bit565::R(unsigned x) const { return((((const uint16_t*)Data1D)[x]>>8)&0xF8); } uint32_t Raster1D_16Bit565::G(unsigned x) const { return((((const uint16_t*)Data1D)[x]>>3)&0xFC); } uint32_t Raster1D_16Bit565::B(unsigned x) const { return((((const uint16_t*)Data1D)[x]&0x1F)<<3); } #ifdef _REENTRANT uint32_t Raster1D_16Bit565::PTR_GetValue1D(const void *RAW_Data1D, unsigned x) const { if(x>=Size1D) return 0; uint32_t val = ((uint16_t *)RAW_Data1D)[x]; return ((val&0x1F)<<19) | ((val&0x7E0)<<5) | ((val&0xF800)>>8); } void Raster1D_16Bit565::PTR_SetValue1D(void *RAW_Data1D, unsigned x, uint32_t NewValue) const { if(Size1D<=x) return; ((uint16_t *)RAW_Data1D)[x] = (uint16_t)(((NewValue&0xF8)<<8) | ((NewValue&0xFC00)>>5) | ((NewValue&0xF80000)>>19)); } #endif /* 8 bit planes for 3 channels R,G,B */ uint32_t Raster1D_8BitRGB::GetValue1D(unsigned x) const { if(x>=Size1D) return 0; x *= 3; return((uint32_t)(((const uint8_t *)Data1D)[x]) | ((uint32_t)(((const uint8_t *)Data1D)[x+1])<<8) | ((uint32_t)(((const uint8_t *)Data1D)[x+2])<<16)); } void Raster1D_8BitRGB::SetValue1D(unsigned x, uint32_t NewValue) { if(Size1D<=x) return; x *= 3; ((uint8_t *)Data1D)[x] = NewValue & 0xFF; ((uint8_t *)Data1D)[x+1] = (NewValue>>8) & 0xFF; ((uint8_t *)Data1D)[x+2] = (NewValue>>16) & 0xFF; } void Raster1D_8BitRGB::Get24BitRGB(void *Buffer24Bit) const { memcpy(Buffer24Bit,Data1D,3*Size1D); } void Raster1D_8BitRGB::Get(unsigned index, RGBQuad *RGB) const { uint8_t *ptrb; if(RGB==NULL || Data1D==NULL || Size1DR = *ptrb++; RGB->G = *ptrb++; RGB->B = *ptrb; RGB->O = 0; } void Raster1D_8BitRGB::Set(const Raster1DAbstract &R1) { if(R1.Channels()==3) { switch(R1.GetPlanes()) { case 3*8: memcpy(Data1D,R1.Data1D,3*Size1D); return; case 3*16:Conv16_8((uint8_t *)Data1D,(const uint16_t *)R1.Data1D,3*Size1D); return; case 3*32:Conv32_8((uint8_t *)Data1D,(const uint32_t *)R1.Data1D,3*Size1D); return; } } Raster1DAbstractRGB::Set(R1); } #ifdef OPTIMISE_SPEED void Raster1D_8BitRGB::Set(unsigned x, const RGBQuad *RGB) { if(Size1D<=x || RGB==NULL) return; x *= 3; ((uint8_t *)Data1D)[x] = RGB->R & 0xFF; ((uint8_t *)Data1D)[x+1] = RGB->G & 0xFF; ((uint8_t *)Data1D)[x+2] = RGB->B & 0xFF; } #endif #ifdef _REENTRANT uint32_t Raster1D_8BitRGB::PTR_GetValue1D(const void *RAW_Data1D, unsigned x) const { if(x>=Size1D) return 0; x *= 3; return((uint32_t)(((uint8_t *)RAW_Data1D)[x]) | ((uint32_t)(((uint8_t *)RAW_Data1D)[x+1])<<8) | ((uint32_t)(((uint8_t *)RAW_Data1D)[x+2])<<16)); } void Raster1D_8BitRGB::PTR_SetValue1D(void *RAW_Data1D, unsigned x, uint32_t NewValue) const { if(Size1D<=x) return; x *= 3; ((uint8_t *)RAW_Data1D)[x] = NewValue & 0xFF; ((uint8_t *)RAW_Data1D)[x+1] = (NewValue>>8) & 0xFF; ((uint8_t *)RAW_Data1D)[x+2] = (NewValue>>16) & 0xFF; } #endif void Raster1D_8BitRGB::Peel8Bit(void *Buffer8Bit, uint8_t plane8) const { if((plane8 & 0x3)!=0 || plane8>16) {Raster1DAbstract::Peel8Bit(Buffer8Bit,plane8); return;} Peel8BitNStep((uint8_t*)Buffer8Bit, (plane8>>3)+(const uint8_t*)Data1D, Size1D, 3); } void Raster1D_8BitRGB::Join8Bit(const void *Buffer8Bit, uint8_t plane8) { if((plane8 & 0x3)!=0 || plane8>16) {Raster1DAbstract::Join8Bit(Buffer8Bit,plane8); return;} Join8BitNStep((const uint8_t*)Buffer8Bit, (plane8>>3)+(uint8_t*)Data1D, Size1D, 3); } /** 16 bit planes for 3 channels R,G,B */ uint32_t Raster1D_16BitRGB::GetValue1D(unsigned x) const { if(x>=Size1D) return 0; x *= 6; #ifdef HI_ENDIAN return((uint32_t)((const uint8_t *)Data1D)[x+0] | ((uint32_t)((const uint8_t *)Data1D)[x+2])<<8 | ((uint32_t)((const uint8_t *)Data1D)[x+4])<<16); #else return((uint32_t)((const uint8_t *)Data1D)[x+1] | ((uint32_t)((const uint8_t *)Data1D)[x+3])<<8 | ((uint32_t)((const uint8_t *)Data1D)[x+5])<<16); #endif } void Raster1D_16BitRGB::SetValue1D(unsigned x, uint32_t NewValue) { if(Size1D<=x) return; x *= 3; ((uint16_t *)Data1D)[x] = (NewValue & 0xFF) * 0x101; NewValue >>= 8; ((uint16_t *)Data1D)[x+1] = (NewValue & 0xFF) * 0x101; NewValue >>= 8; ((uint16_t *)Data1D)[x+2] = (NewValue & 0xFF) * 0x101; } void Raster1D_16BitRGB::Get24BitRGB(void *Buffer24Bit) const { Conv16_8((unsigned char*)Buffer24Bit, (uint16_t*)Data1D, 3*Size1D); } void Raster1D_16BitRGB::Get(unsigned index, RGBQuad *RGB) const { const uint16_t *ptrw; if(RGB==NULL || Data1D==NULL || Size1DR = *ptrw++; RGB->G = *ptrw++; RGB->B = *ptrw++; } void Raster1D_16BitRGB::Set(const Raster1DAbstract &R1) { if(R1.Channels()==3) { switch(R1.GetPlanes()) { case 3*8: Conv8_16((uint16_t *)Data1D,(const uint8_t *)R1.Data1D,3*Size1D); return; case 3*16:memcpy(Data1D,R1.Data1D,6*Size1D); // 3*sizeof(WORD) return; case 3*32:Conv32_16((uint16_t *)Data1D,(const uint32_t *)R1.Data1D,3*Size1D); return; } } Raster1DAbstractRGB::Set(R1); } #ifdef _REENTRANT uint32_t Raster1D_16BitRGB::PTR_GetValue1D(const void *RAW_Data1D, unsigned x) const { if(x>=Size1D) return 0; x *= 6; #ifdef HI_ENDIAN return((uint32_t)((const uint8_t *)RAW_Data1D)[x+0] | ((uint32_t)((const uint8_t *)RAW_Data1D)[x+2])<<8 | ((uint32_t)((const uint8_t *)RAW_Data1D)[x+4])<<16); #else return((uint32_t)((const uint8_t *)RAW_Data1D)[x+1] | ((uint32_t)((const uint8_t *)RAW_Data1D)[x+3])<<8 | ((uint32_t)((const uint8_t *)RAW_Data1D)[x+5])<<16); #endif } void Raster1D_16BitRGB::PTR_SetValue1D(void *RAW_Data1D, unsigned x, uint32_t NewValue) const { if(Size1D<=x) return; x *= 3; ((uint16_t *)RAW_Data1D)[x] = 0x101 * (NewValue&0xFF); ((uint16_t *)RAW_Data1D)[x+1] = 0x101 * ((NewValue>>8) & 0xFF); ((uint16_t *)RAW_Data1D)[x+2] = 0x101 * ((NewValue>>16) & 0xFF); } #endif /** 32 bit planes for 3 channels R,G,B */ uint32_t Raster1D_32BitRGB::GetValue1D(unsigned x) const { if(x>=Size1D) return 0; x *= 12; #ifdef HI_ENDIAN return((uint32_t)((const uint8_t *)Data1D)[x+0] | ((uint32_t)((const uint8_t *)Data1D)[x+4])<<8 | ((uint32_t)((const uint8_t *)Data1D)[x+8])<<16); #else return((uint32_t)((const uint8_t *)Data1D)[x+3] | ((uint32_t)((const uint8_t *)Data1D)[x+7])<<8 | ((uint32_t)((const uint8_t *)Data1D)[x+11])<<16); #endif } void Raster1D_32BitRGB::SetValue1D(unsigned x, uint32_t NewValue) { if(Size1D<=x) return; x *= 3; ((uint32_t *)Data1D)[x] = (NewValue & 0xFF) * 0x1010101; NewValue >>= 8; ((uint32_t *)Data1D)[x+1] = (NewValue & 0xFF) * 0x1010101; NewValue >>= 8; ((uint32_t *)Data1D)[x+2] = (NewValue & 0xFF) * 0x1010101; } void Raster1D_32BitRGB::Get24BitRGB(void *Buffer24Bit) const { Conv32_8((unsigned char*)Buffer24Bit, (uint32_t*)Data1D, 3*Size1D); } void Raster1D_32BitRGB::Get(unsigned index, RGBQuad *RGB) const { const uint32_t *ptrw; if(RGB==NULL || Data1D==NULL || Size1DR = *ptrw++; RGB->G = *ptrw++; RGB->B = *ptrw++; } void Raster1D_32BitRGB::Set(const Raster1DAbstract &R1) { if(R1.Channels()==3) { switch(R1.GetPlanes()) { case 3*8: Conv8_32((uint32_t *)Data1D,(const uint8_t *)R1.Data1D,3*Size1D); return; case 3*16:Conv16_32((uint32_t *)Data1D,(const uint16_t *)R1.Data1D,3*Size1D); return; case 3*32:memcpy(Data1D,R1.Data1D,4*3*Size1D); return; } } Raster1DAbstractRGB::Set(R1); } #ifdef _REENTRANT uint32_t Raster1D_32BitRGB::PTR_GetValue1D(const void *RAW_Data1D, unsigned x) const { if(x>=Size1D) return 0; x *= 12; #ifdef HI_ENDIAN return((uint32_t)((const uint8_t *)RAW_Data1D)[x+0] | ((uint32_t)((const uint8_t *)RAW_Data1D)[x+4])<<8 | ((uint32_t)((const uint8_t *)RAW_Data1D)[x+8])<<16); #else return((uint32_t)((const uint8_t *)RAW_Data1D)[x+3] | ((uint32_t)((const uint8_t *)RAW_Data1D)[x+7])<<8 | ((uint32_t)((const uint8_t *)RAW_Data1D)[x+11])<<16); #endif } void Raster1D_32BitRGB::PTR_SetValue1D(void *RAW_Data1D, unsigned x, uint32_t NewValue) const { if(Size1D<=x) return; x *= 3; ((uint32_t *)RAW_Data1D)[x] = (NewValue&0xFF) * 0x01010101; ((uint32_t *)RAW_Data1D)[x+1] = ((NewValue>>8)&0xFF) * 0x01010101; ((uint32_t *)RAW_Data1D)[x+2] = ((NewValue>>16)&0xFF) * 0x01010101; } #endif /* 32 bit planes FLOAT RGB */ uint32_t Raster1D_32FltBitRGB::GetValue1D(unsigned x) const { if(x>=Size1D) return 0; x *= 3; const uint8_t R = (((float *)Data1D)[x]-Min) * (Max-Min); const uint8_t G = (((float *)Data1D)[x+1]-Min) * (Max-Min); const uint8_t B = (((float *)Data1D)[x+2]-Min) * (Max-Min); return( R | (uint32_t)G<<8 | (uint32_t)B<<16); } double Raster1D_32FltBitRGB::GetValue1Dd(unsigned x) const { if(x>=Size1D) return 0; x *= 3; return((((float *)Data1D)[x]+((float *)Data1D)[x+1]+((float *)Data1D)[x+2])/3); }; void Raster1D_32FltBitRGB::SetValue1D(unsigned x, uint32_t NewValue) { if(x>=Size1D) return; x *= 3; ((float *)Data1D)[x] = Min + (float)(NewValue&0xFF)/(Max-Min); ((float *)Data1D)[x+1] = Min + (float)((NewValue>>8)&0xFF)/(Max-Min); ((float *)Data1D)[x+2] = Min + (float)((NewValue>>16)&0xFF)/(Max-Min); return; } void Raster1D_32FltBitRGB::SetValue1Dd(unsigned x, double NewValue) { if(x>=Size1D) return; x *= 3; ((float *)Data1D)[x] = ((float *)Data1D)[x+1] = ((float *)Data1D)[x+2] = NewValue; return; } uint32_t Raster1D_32FltBitRGB::GetValue1DRAW(unsigned x) const { if(x<3*Size1D) return (((float *)Data1D)[x]-Min) * (Max-Min); return(0); } void Raster1D_32FltBitRGB::SetValue1DRAW(unsigned x, uint32_t NewValue) { if(x<3*Size1D) ((float *)Data1D)[x] = (NewValue+Min)/(Max-Min); }; #ifdef _REENTRANT uint32_t Raster1D_32FltBitRGB::PTR_GetValue1DRAW(const void *RAW_Data1D, unsigned x) const { if(x < 3*Size1D) { return (((float *)RAW_Data1D)[x]-Min) * (Max-Min); } return(0); } void Raster1D_32FltBitRGB::PTR_SetValue1DRAW(void *RAW_Data1D, unsigned x, uint32_t NewValue) { if(x<3*Size1D) { ((float *)RAW_Data1D)[x] = Min + (float)(NewValue&0xFF)/(Max-Min); } } uint32_t Raster1D_32FltBitRGB::PTR_GetValue1D(const void *RAW_Data1D, unsigned x) const { if(x>=Size1D) return 0; RAW_Data1D = (float*)RAW_Data1D + 3*x; const uint8_t R = (((float *)RAW_Data1D)[0]-Min) * (Max-Min); const uint8_t G = (((float *)RAW_Data1D)[1]-Min) * (Max-Min); const uint8_t B = (((float *)RAW_Data1D)[2]-Min) * (Max-Min); return( R | (uint32_t)G<<8 | (uint32_t)B<<16); } double Raster1D_32FltBitRGB::PTR_GetValue1Dd(const void *RAW_Data1D, unsigned x) const { if(x>=Size1D) return 0; RAW_Data1D = (float*)RAW_Data1D + 3*x; return((((float *)Data1D)[x]+((float *)RAW_Data1D)[x+1]+((float *)RAW_Data1D)[x+2])/3); }; void Raster1D_32FltBitRGB::PTR_SetValue1D(void *RAW_Data1D, unsigned x, uint32_t NewValue) const { if(x>=Size1D) return; RAW_Data1D = (float*)RAW_Data1D + 3*x; ((float *)RAW_Data1D)[0] = Min + (float)(NewValue&0xFF)/(Max-Min); ((float *)RAW_Data1D)[1] = Min + (float)((NewValue>>8)&0xFF)/(Max-Min); ((float *)RAW_Data1D)[2] = Min + (float)((NewValue>>16)&0xFF)/(Max-Min); return; } void Raster1D_32FltBitRGB::PTR_SetValue1Dd(void *RAW_Data1D, unsigned x, double NewValue) const { if(x>=Size1D) return; x *= 3; ((float *)RAW_Data1D)[x] = ((float *)RAW_Data1D)[x+1] = ((float *)RAW_Data1D)[x+2] = NewValue; return; } #endif /** 8 bit planes for 4 channels R,G,B, A */ uint32_t Raster1D_8BitRGBA::GetValue1D(unsigned x) const { if(x>=Size1D) return 0; #ifdef HI_ENDIAN return __builtin_bswap32(((uint32_t *)Data1D)[x]); #else return ((uint32_t *)Data1D)[x]; #endif } void Raster1D_8BitRGBA::SetValue1D(unsigned x, uint32_t NewValue) { if(Size1D<=x) return; ((uint32_t *)Data1D)[x] = #ifdef HI_ENDIAN __builtin_bswap32(NewValue); #else NewValue; #endif } void Raster1D_8BitRGBA::Get(unsigned x, RGBQuad *RGB) const { const uint32_t d = ((uint32_t *)Data1D)[x]; #ifdef HI_ENDIAN RGB->O = d & 0xFF; RGB->B = (d>>8) & 0xFF; RGB->G = (d>>16) & 0xFF; RGB->R = (d>>24) & 0xFF; #else RGB->R = d & 0xFF; RGB->G = (d>>8) & 0xFF; RGB->B = (d>>16) & 0xFF; RGB->O = (d>>24) & 0xFF; #endif } void Raster1D_8BitRGBA::Get24BitRGB(void *Buffer24Bit) const { uint8_t *BBuffer24Bit = (uint8_t *)Buffer24Bit; if(Buffer24Bit==NULL) return; for(unsigned x=0; x>24) & 0xFF; *BBuffer24Bit++ = (d>>16) & 0xFF; *BBuffer24Bit++ = (d>>8) & 0xFF; #else *BBuffer24Bit++ = d & 0xFF; *BBuffer24Bit++ = (d>>8) & 0xFF; *BBuffer24Bit++ = (d>>16) & 0xFF; #endif } } void Raster1D_8BitRGBA::Set(const Raster1DAbstract &R1) { if(R1.Channels()==4) { switch(R1.GetPlanes()) { case 4*8: memcpy(Data1D,R1.Data1D,4*Size1D); return; case 4*16:Conv16_8((uint8_t *)Data1D,(const uint16_t *)R1.Data1D,4*Size1D); return; case 4*32:Conv32_8((uint8_t *)Data1D,(const uint32_t *)R1.Data1D,4*Size1D); return; } } Raster1DAbstractRGBA::Set(R1); } #ifdef _REENTRANT uint32_t Raster1D_8BitRGBA::PTR_GetValue1D(const void *RAW_Data1D, unsigned x) const { if(x>=Size1D) return 0; return #ifdef HI_ENDIAN __builtin_bswap32 #endif (((const uint32_t*)RAW_Data1D)[x]); } void Raster1D_8BitRGBA::PTR_SetValue1D(void *RAW_Data1D, unsigned x, uint32_t NewValue) const { if(Size1D<=x) return; ((uint32_t *)RAW_Data1D)[x] = #ifdef HI_ENDIAN __builtin_bswap32(NewValue); #else NewValue; #endif } #endif void Raster1D_8BitRGBA::Peel8Bit(void *Buffer8Bit, uint8_t plane8) const { if((plane8 & 0x3)!=0 || plane8>24) {Raster1DAbstract::Peel8Bit(Buffer8Bit,plane8); return;} Peel8BitNStep((uint8_t*)Buffer8Bit, (plane8>>3)+(const uint8_t*)Data1D, Size1D, 4); } void Raster1D_8BitRGBA::Join8Bit(const void *Buffer8Bit, uint8_t plane8) { if((plane8 & 0x3)!=0 || plane8>24) {Raster1DAbstract::Join8Bit(Buffer8Bit,plane8); return;} Join8BitNStep((const uint8_t*)Buffer8Bit, (plane8>>3)+(uint8_t*)Data1D, Size1D, 4); } /** 16 bit planes for 4 channels R,G,B, A */ uint32_t Raster1D_16BitRGBA::GetValue1D(unsigned x) const { if(x>=Size1D) return 0; x *= 8; #ifdef HI_ENDIAN return((uint32_t)((const uint8_t *)Data1D)[x+0] | ((uint32_t)((const uint8_t *)Data1D)[x+2])<<8 | ((uint32_t)((const uint8_t *)Data1D)[x+4])<<16 | ((uint32_t)((const uint8_t *)Data1D)[x+6])<<24); #else return((uint32_t)((const uint8_t *)Data1D)[x+1] | ((uint32_t)((const uint8_t *)Data1D)[x+3])<<8 | ((uint32_t)((const uint8_t *)Data1D)[x+5])<<16 | ((uint32_t)((const uint8_t *)Data1D)[x+7])<<24); #endif } void Raster1D_16BitRGBA::SetValue1D(unsigned x, uint32_t NewValue) { if(Size1D<=x) return; x *= 4; ((uint16_t *)Data1D)[x] = (NewValue & 0xFF) * 0x101; NewValue >>= 8; ((uint16_t *)Data1D)[x+1] = (NewValue & 0xFF) * 0x101; NewValue >>= 8; ((uint16_t *)Data1D)[x+2] = (NewValue & 0xFF) * 0x101; NewValue >>= 8; ((uint16_t *)Data1D)[x+3] = (NewValue & 0xFF) * 0x101; } #ifdef _REENTRANT uint32_t Raster1D_16BitRGBA::PTR_GetValue1D(const void *RAW_Data1D, unsigned x) const { if(x>=Size1D) return 0; RAW_Data1D = (const uint8_t *)RAW_Data1D + 8*x; #ifdef HI_ENDIAN return((uint32_t)((const uint8_t *)RAW_Data1D)[0] | ((uint32_t)((const uint8_t *)RAW_Data1D)[2])<<8 | ((uint32_t)((const uint8_t *)RAW_Data1D)[4])<<16 | ((uint32_t)((const uint8_t *)RAW_Data1D)[6])<<24); #else return((uint32_t)((const uint8_t *)RAW_Data1D)[1] | ((uint32_t)((const uint8_t *)RAW_Data1D)[3])<<8 | ((uint32_t)((const uint8_t *)RAW_Data1D)[5])<<16 | ((uint32_t)((const uint8_t *)RAW_Data1D)[7])<<24); #endif } void Raster1D_16BitRGBA::PTR_SetValue1D(void *RAW_Data1D, unsigned x, uint32_t NewValue) const { if(Size1D<=x) return; RAW_Data1D = ((uint8_t *)RAW_Data1D) + 8 * x; ((uint16_t *)RAW_Data1D)[0] = (NewValue & 0xFF) * 0x101; NewValue >>= 8; ((uint16_t *)RAW_Data1D)[1] = (NewValue & 0xFF) * 0x101; NewValue >>= 8; ((uint16_t *)RAW_Data1D)[2] = (NewValue & 0xFF) * 0x101; NewValue >>= 8; ((uint16_t *)RAW_Data1D)[3] = (NewValue & 0xFF) * 0x101; } #endif void Raster1D_16BitRGBA::Set(const Raster1DAbstract &R1) { if(R1.Channels()==4) { switch(R1.GetPlanes()) { case 8*4: Conv8_16((uint16_t *)Data1D,(const uint8_t *)R1.Data1D,4*Size1D); return; case 16*4:memcpy(Data1D,R1.Data1D,4*Size1D); return; case 32*4:Conv32_16((uint16_t *)Data1D,(const uint32_t *)R1.Data1D,4*Size1D); return; } } Raster1DAbstractRGBA::Set(R1); } /** 32 bit planes for 4 channels R,G,B, A */ uint32_t Raster1D_32BitRGBA::GetValue1D(unsigned x) const { if(x>=Size1D) return 0; x *= 16; #ifdef HI_ENDIAN return((uint32_t)((const uint8_t *)Data1D)[x+0] | ((uint32_t)((const uint8_t *)Data1D)[x+4])<<8 | ((uint32_t)((const uint8_t *)Data1D)[x+8])<<16 | ((uint32_t)((const uint8_t *)Data1D)[x+12])<<24); #else return((uint32_t)((const uint8_t *)Data1D)[x+3] | ((uint32_t)((const uint8_t *)Data1D)[x+7])<<8 | ((uint32_t)((const uint8_t *)Data1D)[x+11])<<16 | ((uint32_t)((const uint8_t *)Data1D)[x+15])<<24); #endif } void Raster1D_32BitRGBA::SetValue1D(unsigned x, uint32_t NewValue) { if(Size1D<=x) return; x *= 4; ((uint32_t *)Data1D)[x] = (NewValue & 0xFF) * 0x1010101; NewValue >>= 8; ((uint32_t *)Data1D)[x+1] = (NewValue & 0xFF) * 0x1010101; NewValue >>= 8; ((uint32_t *)Data1D)[x+2] = (NewValue & 0xFF) * 0x1010101; NewValue >>= 8; ((uint32_t *)Data1D)[x+3] = (NewValue & 0xFF) * 0x1010101; } #ifdef _REENTRANT uint32_t Raster1D_32BitRGBA::PTR_GetValue1D(const void *RAW_Data1D, unsigned x) const { if(x>=Size1D) return 0; RAW_Data1D = (const uint8_t*)RAW_Data1D + x*16; #ifdef HI_ENDIAN return((uint32_t)((const uint8_t *)RAW_Data1D)[0] | ((uint32_t)((const uint8_t *)RAW_Data1D)[4])<<8 | ((uint32_t)((const uint8_t *)RAW_Data1D)[8])<<16 | ((uint32_t)((const uint8_t *)RAW_Data1D)[12])<<24); #else return((uint32_t)((const uint8_t *)RAW_Data1D)[3] | ((uint32_t)((const uint8_t *)RAW_Data1D)[7])<<8 | ((uint32_t)((const uint8_t *)RAW_Data1D)[11])<<16 | ((uint32_t)((const uint8_t *)RAW_Data1D)[15])<<24); #endif } void Raster1D_32BitRGBA::PTR_SetValue1D(void *RAW_Data1D, unsigned x, uint32_t NewValue) const { if(Size1D<=x) return; RAW_Data1D = (uint8_t*)RAW_Data1D + x*16; ((uint32_t *)RAW_Data1D)[0] = (NewValue & 0xFF) * 0x1010101; NewValue >>= 8; ((uint32_t *)RAW_Data1D)[1] = (NewValue & 0xFF) * 0x1010101; NewValue >>= 8; ((uint32_t *)RAW_Data1D)[2] = (NewValue & 0xFF) * 0x1010101; NewValue >>= 8; ((uint32_t *)RAW_Data1D)[3] = (NewValue & 0xFF) * 0x1010101; } #endif void Raster1D_32BitRGBA::Set(const Raster1DAbstract &R1) { if(R1.Channels()==4) { switch(R1.GetPlanes()) { case 8*4: Conv8_32((uint32_t *)Data1D,(const uint8_t *)R1.Data1D,4*Size1D); return; case 16*4: Conv16_32((uint32_t *)Data1D,(const uint16_t *)R1.Data1D,4*Size1D); return; case 32*4:memcpy(Data1D,R1.Data1D,4*Size1D); return; } } Raster1DAbstractRGBA::Set(R1); } /* void Raster1D_24Bit::Get(Raster1DAbstract &R1) const { uint8_t *N_Buffer24Bit = (uint8_t *)R1->Data1D; uint32_t val; int i; int shift; if(Buffer24Bit==NULL) return; shift = 24-GetPlanes(); for(i=0;i0) val <<= shift; else val >>= -shift; *N_Buffer24Bit++ = val&0xFF; *N_Buffer24Bit++ = (val>>8)&0xFF; *N_Buffer24Bit++ = (val>>16)&0xFF; } } */ /* 32 bit planes FLOAT RGBA */ uint32_t Raster1D_32FltBitRGBA::GetValue1D(unsigned x) const { if(x>=Size1D) return 0; x *= 4; const uint8_t R = (((float *)Data1D)[x]-Min) * (Max-Min); const uint8_t G = (((float *)Data1D)[x+1]-Min) * (Max-Min); const uint8_t B = (((float *)Data1D)[x+2]-Min) * (Max-Min); const uint8_t O = (((float *)Data1D)[x+3]-Min) * (Max-Min); return( R | (uint32_t)G<<8 | (uint32_t)B<<16 | (uint32_t)O<<24); } double Raster1D_32FltBitRGBA::GetValue1Dd(unsigned x) const { if(x>=Size1D) return 0; x *= 4; return((((float *)Data1D)[x]+((float *)Data1D)[x+1]+((float *)Data1D)[x+2])/3); }; void Raster1D_32FltBitRGBA::SetValue1D(unsigned x, uint32_t NewValue) { if(x>=Size1D) return; x *= 4; ((float *)Data1D)[x] = Min + (float)(NewValue&0xFF)/(Max-Min); ((float *)Data1D)[x+1] = Min + (float)((NewValue>>8)&0xFF)/(Max-Min); ((float *)Data1D)[x+2] = Min + (float)((NewValue>>16)&0xFF)/(Max-Min); ((float *)Data1D)[x+3] = Min + (float)((NewValue>>24)&0xFF)/(Max-Min); return; } void Raster1D_32FltBitRGBA::SetValue1Dd(unsigned x, double NewValue) { if(x>=Size1D) return; x *= 4; ((float *)Data1D)[x] = ((float *)Data1D)[x+1] = ((float *)Data1D)[x+2] = NewValue; return; } uint32_t Raster1D_32FltBitRGBA::GetValue1DRAW(unsigned x) const { if(x<4*Size1D) return (((float *)Data1D)[x]-Min) * (Max-Min); return(0); } void Raster1D_32FltBitRGBA::SetValue1DRAW(unsigned x, uint32_t NewValue) { if(x<4*Size1D) ((float *)Data1D)[x] = (NewValue+Min)/(Max-Min); }; #ifdef _REENTRANT uint32_t Raster1D_32FltBitRGBA::PTR_GetValue1DRAW(const void *RAW_Data1D, unsigned x) const { if(x < 4*Size1D) { return (((float *)RAW_Data1D)[x]-Min) * (Max-Min); } return(0); } void Raster1D_32FltBitRGBA::PTR_SetValue1DRAW(void *RAW_Data1D, unsigned x, uint32_t NewValue) { if(x<4*Size1D) { ((float *)RAW_Data1D)[x] = Min + (float)(NewValue&0xFF)/(Max-Min); } } uint32_t Raster1D_32FltBitRGBA::PTR_GetValue1D(const void *RAW_Data1D, unsigned x) const { if(x>=Size1D) return 0; RAW_Data1D = (float*)RAW_Data1D + 4*x; const uint8_t R = (((float *)RAW_Data1D)[0]-Min) * (Max-Min); const uint8_t G = (((float *)RAW_Data1D)[1]-Min) * (Max-Min); const uint8_t B = (((float *)RAW_Data1D)[2]-Min) * (Max-Min); const uint8_t O = (((float *)RAW_Data1D)[3]-Min) * (Max-Min); return( R | (uint32_t)G<<8 | (uint32_t)B<<16 | (uint32_t)O<<24); } double Raster1D_32FltBitRGBA::PTR_GetValue1Dd(const void *RAW_Data1D, unsigned x) const { if(x>=Size1D) return 0; RAW_Data1D = (float*)RAW_Data1D + 4*x; return((((float *)Data1D)[x]+((float *)RAW_Data1D)[x+1]+((float *)RAW_Data1D)[x+2])/3); }; void Raster1D_32FltBitRGBA::PTR_SetValue1D(void *RAW_Data1D, unsigned x, uint32_t NewValue) const { if(x>=Size1D) return; RAW_Data1D = (float*)RAW_Data1D + 4*x; ((float *)RAW_Data1D)[0] = Min + (float)(NewValue&0xFF)/(Max-Min); ((float *)RAW_Data1D)[1] = Min + (float)((NewValue>>8)&0xFF)/(Max-Min); ((float *)RAW_Data1D)[2] = Min + (float)((NewValue>>16)&0xFF)/(Max-Min); ((float *)RAW_Data1D)[3] = Min + (float)((NewValue>>24)&0xFF)/(Max-Min); return; } void Raster1D_32FltBitRGBA::PTR_SetValue1Dd(void *RAW_Data1D, unsigned x, double NewValue) const { if(x>=Size1D) return; x *= 3; ((float *)RAW_Data1D)[x] = ((float *)RAW_Data1D)[x+1] = ((float *)RAW_Data1D)[x+2] = NewValue; return; } #endif /* --------------------------------------------------------------------------------- */ Raster1DAbstractRGB *CreateRaster1DRGB(unsigned Size1D, int Planes) { Raster1DAbstractRGB *Raster=NULL; switch(Planes) { case 5: Raster=new Raster1D_16Bit565; break; case 8: Raster=new Raster1D_8BitRGB; break; case 16: Raster=new Raster1D_16BitRGB; break; case 32: Raster=new Raster1D_32BitRGB; break; case -32:Raster=new Raster1D_32FltBitRGB; break; default:return(NULL); } if(Raster) { if(Size1D>0) { Raster->Allocate1D(Size1D); if(Raster->Data1D==NULL) { delete Raster; return(NULL); } } } return(Raster); } Raster1DAbstractRGBA *CreateRaster1DRGBA(unsigned Size1D, int Planes) { Raster1DAbstractRGBA *Raster=NULL; switch(Planes) { case 8: Raster=new Raster1D_8BitRGBA; break; case 16: Raster=new Raster1D_16BitRGBA; break; case 32: Raster=new Raster1D_32BitRGBA; break; case -32: Raster=new Raster1D_32FltBitRGBA; break; default:return(NULL); } if(Raster) { if(Size1D>0) { Raster->Allocate1D(Size1D); if(Raster->Data1D==NULL) { delete Raster; return(NULL); } } } return(Raster); } /* ==================================================== */ /* ================ Raster 2D abstract class ========== */ /* ==================================================== */ void Raster2DAbstract::Erase2DStub(void) { //printf("Erasing Ras2D |%p|",Data2D); if(Shadow) { Data2D = NULL; Size2D = 0; Erase1DStub(); return; } if(Data2D) { const unsigned SaveSize1D = Size1D; for(unsigned i=0; i=Size2D) return(NULL); Data1D = Data2D[Offset2D]; return(this); } void Raster2DAbstract::Get(unsigned Offset2D, Raster1DAbstract &R1) MP_CONST { if(Data2D==NULL || Offset2D>=Size2D) return; #ifdef _REENTRANT Raster1DAbstract::PTR_Get(Data2D[Offset2D],R1); #else Data1D = Data2D[Offset2D]; ((Raster1DAbstract*)this)->Get(R1); #endif } void Raster2DAbstract::Get(unsigned Offset1D, unsigned Offset2D, RGBQuad *RGB) { if(Data2D==NULL || Offset2D>=Size2D) return; Data1D = Data2D[Offset2D]; ((const Raster1DAbstract*)this)->Get(Offset1D,RGB); //Raster1DAbstract::Get() forces only one method not using VMT. } void Raster2DAbstract::Set(unsigned Offset1D, unsigned Offset2D, const RGBQuad *RGB) { if(Data2D==NULL || Offset2D>=Size2D) return; Data1D = Data2D[Offset2D]; ((Raster1DAbstract*)this)->Set(Offset1D,RGB); //Raster1DAbstract::Set() forces only one method not using VMT. } void Raster2DAbstract::Set(unsigned Offset2D, const Raster1DAbstract &R1) { if(Data2D==NULL || Offset2D>=Size2D) return; #ifdef _REENTRANT Raster1DAbstract::PTR_Set(Data2D[Offset2D],R1); #else Data1D = Data2D[Offset2D]; ((Raster1DAbstract*)this)->Set(R1); #endif } uint32_t Raster2DAbstract::GetValue2D(unsigned Offset1D, unsigned Offset2D) MP_CONST { if(Data2D==NULL || Offset2D>=Size2D) return(0); #ifdef _REENTRANT return PTR_GetValue1D(Data2D[Offset2D],Offset1D); #else Data1D = Data2D[Offset2D]; return GetValue1D(Offset1D); #endif } double Raster2DAbstract::GetValue2Dd(unsigned Offset1D, unsigned Offset2D) MP_CONST { if(Data2D==NULL || Offset2D>=Size2D) return(0); #ifdef _REENTRANT return PTR_GetValue1Dd(Data2D[Offset2D],Offset1D); #else Data1D = Data2D[Offset2D]; return(GetValue1Dd(Offset1D)); #endif } void Raster2DAbstract::SetValue2D(unsigned Offset1D, unsigned Offset2D, long x) { if(Data2D==NULL || Offset2D>=Size2D) return; #ifdef _REENTRANT PTR_SetValue1D(Data2D[Offset2D],Offset1D,x); #else Data1D = Data2D[Offset2D]; SetValue1D(Offset1D,x); #endif } void Raster2DAbstract::SetValue2Dd(unsigned Offset1D, unsigned Offset2D, double x) { if(Data2D==NULL || Offset2D>=Size2D) return; #ifdef _REENTRANT PTR_SetValue1Dd(Data2D[Offset2D],Offset1D,x); #else Data1D = Data2D[Offset2D]; SetValue1Dd(Offset1D,x); #endif } #if defined(_REENTRANT) && defined(RASTER_3D) uint32_t Raster2DAbstract::PTR_GetValue2D(const void **RAW_Data2D, unsigned Offset1D, unsigned Offset2D) const { if(RAW_Data2D==NULL || Offset2D>=Size2D) return(0); return PTR_GetValue1D(RAW_Data2D[Offset2D],Offset1D); } double Raster2DAbstract::PTR_GetValue2Dd(const void **RAW_Data2D, unsigned Offset1D, unsigned Offset2D) const { if(RAW_Data2D==NULL || Offset2D>=Size2D) return(0); return PTR_GetValue1Dd(RAW_Data2D[Offset2D],Offset1D); } void Raster2DAbstract::PTR_SetValue2D(void **RAW_Data2D, unsigned Offset1D, unsigned Offset2D, uint32_t x) const { if(RAW_Data2D==NULL || Offset2D>=Size2D) return; PTR_SetValue1D(RAW_Data2D[Offset2D],Offset1D,x); } void Raster2DAbstract::PTR_SetValue2Dd(void **RAW_Data2D, unsigned Offset1D, unsigned Offset2D, double x) const { if(RAW_Data2D==NULL || Offset2D>=Size2D) return; PTR_SetValue1Dd(RAW_Data2D[Offset2D],Offset1D,x); } void Raster2DAbstract::PTR_Get(const void **RAW_Data2D, unsigned Offset2D, Raster1DAbstract &R1) const { if(RAW_Data2D==NULL || Offset2D>=Size2D) return; Raster1DAbstract::PTR_Get(RAW_Data2D[Offset2D], R1); } void Raster2DAbstract::PTR_Set(void **RAW_Data2D, unsigned Offset2D, const Raster1DAbstract &R1) { if(RAW_Data2D==NULL || Offset2D>=Size2D) return; Raster1DAbstract::PTR_Set(RAW_Data2D[Offset2D], R1); } #endif /** Make the current 2D object to act like Raster1DAbstractRGB. * This method modifies internal variable Data2D and thus it IS NOT THREAD SAFE. */ Raster1DAbstractRGB *Raster2DAbstractRGB::GetRowRasterRGB(unsigned Offset2D) { if(Data2D==NULL || Offset2D>=Size2D) return(NULL); Data1D = Data2D[Offset2D]; return(this); } uint32_t Raster2DAbstractRGB::GetValue2DRAW(unsigned Offset1D, unsigned Offset2D) { if(Data2D==NULL || Offset2D>=Size2D) return(0); #if defined(_REENTRANT) return(PTR_GetValue1DRAW(Data2D[Offset2D],Offset1D)); #else Data1D = Data2D[Offset2D]; return(GetValue1DRAW(Offset1D)); #endif } void Raster2DAbstractRGB::SetValue2DRAW(unsigned Offset1D, unsigned Offset2D, uint32_t x) { if(Data2D==NULL || Offset2D>=Size2D) return; #if defined(_REENTRANT) PTR_SetValue1DRAW(Data2D[Offset2D],Offset1D,x); #else Data1D = Data2D[Offset2D]; SetValue1DRAW(Offset1D,x); #endif } uint32_t Raster2DAbstractRGBA::GetValue2DRAW(unsigned Offset1D, unsigned Offset2D) { if(Data2D==NULL || Offset2D>=Size2D) return(0); #if defined(_REENTRANT) return PTR_GetValue1DRAW(Data2D[Offset2D],Offset1D); #else Data1D = Data2D[Offset2D]; return(GetValue1DRAW(Offset1D)); #endif } void Raster2DAbstractRGBA::SetValue2DRAW(unsigned Offset1D, unsigned Offset2D, uint32_t x) { if(Data2D==NULL || Offset2D>=Size2D) return; Data1D=Data2D[Offset2D]; SetValue1DRAW(Offset1D,x); } /** Create raster with given amount of planes. Negative numbers * are used for floating point rasters. */ Raster2DAbstract *CreateRaster2D(unsigned Size1D, unsigned Size2D, int Planes) { Raster2DAbstract *Raster=NULL; switch(Planes) { case -64:Raster=new Raster2D_64FltBit; break; case -32:Raster=new Raster2D_32FltBit; break; case 0:return(NULL); case 1:Raster=new Raster2D_1Bit; break; case 2:Raster=new Raster2D_2Bit; break; case 4:Raster=new Raster2D_4Bit; break; case 8:Raster=new Raster2D_8Bit; break; case 16:Raster=new Raster2D_16Bit; break; case 24:Raster=new Raster2D_24Bit; break; case 32:Raster=new Raster2D_32Bit; break; #if defined(uint64_t_defined) case 64:Raster=new Raster2D_64Bit; break; #endif default:return(NULL); } if(Raster) { if(Size1D!=0 && Size2D!=0) { Raster->Allocate2D(Size1D,Size2D); if(Raster->Data2D==NULL) { delete Raster; return(NULL); } } } //printf("CreateRaster2D |%p|",Raster->Data2D); return(Raster); } /** Create RGB raster with given amount of planes per channel. */ Raster2DAbstractRGB *CreateRaster2DRGB(unsigned Size1D, unsigned Size2D, int Planes) { Raster2DAbstractRGB *Raster=NULL; switch(Planes) { case 5:Raster=new Raster2D_16Bit565; break; case 8:Raster=new Raster2D_8BitRGB; break; case 16:Raster=new Raster2D_16BitRGB; break; case 32:Raster=new Raster2D_32BitRGB; break; case -32:Raster=new Raster2D_32FltBitRGB; break; default:return(NULL); } if(Raster) { if(Size1D!=0 && Size2D!=0) { Raster->Allocate2D(Size1D,Size2D); if(Raster->Data2D==NULL) { delete Raster; return(NULL); } } } return(Raster); } /** Create RGB raster with given amount of planes per channel. */ Raster2DAbstractRGBA *CreateRaster2DRGBA(unsigned Size1D, unsigned Size2D, int Planes) { Raster2DAbstractRGBA *Raster=NULL; switch(Planes) { case 8:Raster=new Raster2D_8BitRGBA; break; case 16:Raster=new Raster2D_16BitRGBA; break; case 32:Raster=new Raster2D_32BitRGBA; break; case -32:Raster=new Raster2D_32FltBitRGBA; break; default:return(NULL); } if(Raster) { if(Size1D!=0 && Size2D!=0) { Raster->Allocate2D(Size1D,Size2D); if(Raster->Data2D==NULL) { delete Raster; return(NULL); } } } return(Raster); } #ifdef RASTER_3D /* ==================================================== */ /* ================ Raster 3D abstract class ========== */ /* ==================================================== */ void Raster3DAbstract::Erase3DStub(void) { unsigned i,SaveSize2D; if(Shadow) { Data3D = NULL; Size3D = 0; Erase2DStub(); return; } if(Data3D) { SaveSize2D=Size2D; for(i=0;i=Size3D) return(NULL); Data2D = Data3D[Offset3D]; return Raster2DAbstract::GetRowRaster(Offset2D); } /** Make the current 3D object to act like Raster2DAbstract. * This method modifies internal variable Data2D and thus it IS NOT THREAD SAFE. */ Raster2DAbstract *Raster3DAbstract::GetRowRaster(unsigned Offset3D) { if(Data3D==NULL || Offset3D>=Size3D) return(NULL); Data2D = Data3D[Offset3D]; return(this); } uint32_t Raster3DAbstract::GetValue3D(unsigned Offset1D, unsigned Offset2D, unsigned Offset3D) MP_CONST { if(Data3D==NULL || Offset3D>=Size3D) return(0); #ifdef _REENTRANT return PTR_GetValue2D((const void**)(Data3D[Offset3D]),Offset1D,Offset2D); #else Data2D = Data3D[Offset3D]; return GetValue2D(Offset1D,Offset2D); #endif } double Raster3DAbstract::GetValue3Dd(unsigned Offset1D, unsigned Offset2D, unsigned Offset3D) MP_CONST { if(Data3D==NULL || Offset3D>=Size3D) return(0); #ifdef _REENTRANT return PTR_GetValue2Dd((const void**)(Data3D[Offset3D]),Offset1D,Offset2D); #else Data2D = Data3D[Offset3D]; return GetValue2Dd(Offset1D,Offset2D); #endif } void Raster3DAbstract::SetValue3D(unsigned Offset1D, unsigned Offset2D, unsigned Offset3D, uint32_t x) { if(Data3D==NULL || Offset3D>=Size3D) return; #ifdef _REENTRANT PTR_SetValue2D(Data3D[Offset3D],Offset1D,Offset2D,x); #else Data2D = Data3D[Offset3D]; SetValue2D(Offset1D,Offset2D,x); #endif } void Raster3DAbstract::SetValue3Dd(unsigned Offset1D, unsigned Offset2D, unsigned Offset3D, double x) { if(Data3D==NULL || Offset3D>=Size3D) return; #ifdef _REENTRANT PTR_SetValue2Dd(Data3D[Offset3D],Offset1D,Offset2D,x); #else Data2D = Data3D[Offset3D]; SetValue2Dd(Offset1D,Offset2D,x); #endif } void Raster3DAbstract::Get(unsigned Offset2D, unsigned Offset3D, Raster1DAbstract &R1) MP_CONST { if(Data3D==NULL || Offset3D>=Size3D) return; #ifdef _REENTRANT PTR_Get((const void **)Data3D[Offset3D], Offset2D, R1); #else Data2D = Data3D[Offset3D]; Raster2DAbstract::Get(Offset2D,R1); #endif } void Raster3DAbstract::Set(unsigned Offset2D, unsigned Offset3D, const Raster1DAbstract &R1) { if(Data3D==NULL || Offset3D>=Size3D) return; #ifdef _REENTRANT PTR_Set((void **)Data3D[Offset3D], Offset2D, R1); #else Data2D = Data3D[Offset3D]; Raster2DAbstract::Set(Offset2D,R1); #endif } /* Specialised Raster 3D modules */ Raster3DAbstract *CreateRaster3D(unsigned Size1D, unsigned Size2D, unsigned Size3D, int Planes) { Raster3DAbstract *Raster=NULL; switch(Planes) { case -64:Raster=new Raster3D_64FltBit; break; case -32:Raster=new Raster3D_32FltBit; break; case 0:return(NULL); case 1:Raster=new Raster3D_1Bit; break; case 2:Raster=new Raster3D_2Bit; break; case 4:Raster=new Raster3D_4Bit; break; case 8:Raster=new Raster3D_8Bit; break; case 16:Raster=new Raster3D_16Bit; break; case 24:Raster=new Raster3D_24Bit; break; case 32:Raster=new Raster3D_32Bit; break; #if defined(uint64_t_defined) case 64:Raster=new Raster3D_64Bit; break; #endif default:return(NULL); } if(Raster) { if(Size1D!=0 && Size2D!=0 && Size3D!=0) { Raster->Allocate3D(Size1D,Size2D,Size3D); if(Raster->Data3D==NULL) { delete Raster; return(NULL); } } } return(Raster); } Raster3DAbstract *Raster3DAbstract::CreateShadow(void) { Raster3DAbstract *Ras = CreateRaster3D(0,0,0,GetPlanes()); if(Ras!=NULL) { Ras->Shadow = true; Ras->Data3D = Data3D; Ras->Size3D = Size3D; Ras->Data2D = Data2D; Ras->Size2D = Size2D; Ras->Data1D = Data1D; Ras->Size1D = Size1D; } return Ras; } #endif